+0001: # _____   __           

  __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_4) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 0002: # ___  | / /__________ 

 0003: # __   |/ /_  _ \  __ \

 0004: # _  /|  / /  __/ /_/ /

 0005: # /_/ |_/  \___/\____/ 

 0006: 

 0007: # Kessler Controller

 0008: # Jie Fan (jie.f@pm.me)

 0009: 

 0010: # This controller file needs to be compiled with Cython, into a C extension module to be imported into a Python script

 0011: 

 0012: # TODO: Show stats at the end

 0013: # DONE: Verify that frontrun protection's working (shot stealing protection), because it still feels like it's not totally working!

 0014: # DONE: Make it so during a respawn maneuver, if I'm no longer gonna hit anything, I can begin to shoot!

 0015: # TODO: Use the tolerance in the shot for the target selection so I don't just aim for the center all the time

 0016: # KINDA DONE: Add error handling as a catch-all

 0017: # TODO: Analyze each base state, and store analysis results. Like the heuristic FIS, except use more random search. Density affects the movement speed and cruise timesteps. Tune stuff much better.

 0018: # TODO: Add error checks, so that if Neo thinks its done but there's still asteroids left, it'll realize that and re-ingest the updated state and finish off its job. This should NEVER happen though, but in the 1/1000000 chance a new bug happens during the competition, this would catch it.

 0019: # DONE: Tune gc to maybe speed stuff up

 0020: # DONE: Match collision checks with Kessler, including <= vs <

 0021: # DONE: Add iteration boosting algorithm to do more iterations in critical moments

 0022: # DONE: If we're chilling, have mines and lives, go and do some damage!

 0023: # WON'T FIX: Optimally, the target selection will consider mines blowing up asteroids, and having forecasted asteroids there. But this is a super specific condition and it's very complex to implement correctly, so maybe let's just skip this lol. It's probably not worth spending 50 hours implementing something that will rarely come up, and there's plenty of other asteroids I can shoot, and not just ones coming off of a mine blast.

 0024: # WON'T FIX: Remove unnecessary class attributes such as ship thrust range, asteroid mass, to speed up class creation and copying

 0025: # DONE: Differentiate between my mine and adversary's mine, to know whether to shoot size 1's or not

 0026: # TODO: Mine FIS currently doesn't take into account if an asteroid will ALREADY get hit by a mine, and drop another one anyway

 0027: # DONE: When validating a sim is good when there's another ship, make sure the shots hit! The other ship might have shot those asteroids already.

 0028: # DONE: Try a wider random search for maneuvers

 0029: # KINDA DONE: GA to beat the random maneuver search, and narrow down the search space. In crowded areas, don't cruise for as long, for example!

 0030: # TRIED, not faster: Add per-timestep velocities to asteroids and bullets and stuff to save a multiplication

 0031: # TODO: Revisit the aimbot and improve things more

 0032: # NO NEED TO FIX because Kessler changed it so that it'll wait out the bullet, as long as there's still time remaining: If we're gonna die and we're the only ship left, don't shoot a bullet if it doesn't land before I die, because it'll count as a miss

 0033: # EHH WON'T MAKE THIS CHANGE BECAUSE IT'S KINDA BAD AND COMPLEX: Use math to see how the bullet lines up with the asteroid, to predict whether it's gonna hit before doing the bullet sim

 0034: # DONE: get_next_extrapolated_asteroid_collision_time doesn't handle the edges properly! Collisions can't go through the edge but this can predict that. Do the checks!

 0035: # DONE: Improve targeting during maneuvers to maintain random maneuvers. Each sim should target differently, not just always aim at the closest asteroid! But we need to maintain cohesion in the targets from one iteration to the next, so Neo doesn't switch targets randomly within the sim.

 0036: # PROBABLY NOT WORTH ADDING: Add corner camping hardcoded logic

 0037: # PROBABLY NOT WORTH ADDING: Add closing ring freezing

 0038: 

 0039: 

 0040: # POST-XFC 2024 IMPROVEMENT IDEAS:

 0041: # DONE (I THINK): Make it so that if the other ship steals my shots, I realize sooner and avoid shooting.

 0042: # Currently Neo takes up to 2 planning periods to realize, but if I do a second pass check of the planned actions and make sure all shots land,

 0043: # then I can reduce this down to up to 1 planning period of delay. Neo can be only 96% accurate with a good adversary, so hopefully this can be bumped to like 98%.

 0044: # This is VERY important in scenarios with a bullet limit since a missed shot is a missed point

 0045: 

 0046: # DONE: Inspired by OMUlettes taking out the Fuzzifiers by crashing into them, I want to implement the following hard-coded logic:

 0047: # if the other ship is on its last life and I have at least 2 lives:

 0048: #     SLAM INTO THE OTHER SHIP AND TAKE THEIR LAST LIFE

 0049: 

 0050: # TODO: Improve avoiding shooting size-1 asteroids within the blast radius of my own mine.

 0051: # Currently it avoids targeting these, but it could still accidentally hit such asteroids in the way of their intended target

 0052: 

 0053: # DONE: Improve handling low bullet limits. Currently Neo just kinda chills and doesn't use its remaining mines effectively.

 0054: # Improving its behavior here can help get a bit more score. Even sacrificing lives to get a couple more hits could be a good strat.

 0055: 

 0056: # TODO: Ration mines better. Some scenarios Neo uses them too sparingly, and sometimes it dumps them all at the start, and doesn't have any left to use.

 0057: # The former is a larger issue. If there's only 3 seconds left, Neo can dump a mine and it could get a few more hits at basically zero cost

 0058: # The rationing issue might be solvable by scaling up and down what is considered a good number of asteroids within a blast radius. Currently these are hardcoded.

 0059: 

 0060: # DONE: Print out a build date at the start of each run, so during the competition I can make sure the correct version of my controller is run.

 0061: 

 0062: # WON'T FIX: Remove my training wheels artificial limitation of placing mines 3 seconds apart.

 0063: # I can place them as low as 1 second apart, so removing this might add more strategic options.

 0064: # But this will also give Neo more opportunities to bomb itself, so this is hard to implement well.

 0065: 

 0066: # TODO: Consider the time limit better, and adapt my strategy based on that. Currently it's not considered (other than avoiding shooting a bullet that won't land before the time's up).

 0067: # For example, if there's a very long time limit and I have unlimited bullets, then I probably want to focus on killing the other ship first.

 0068: # Otherwise if there's a short time limit, I shouldn't waste time killing the other ship because even if I do,

 0069: # I don't have time to hit all the asteroids myself, and it's better to just shoot asteroids and trust that I'm gaining score quicker than the other team is able to gain score,

 0070: # or at least I'm no worse than the other team

 0071: 

 0072: # DONE: Investigate why Neo just stayed on top of the mine near the end of the scenario for the closing double rings scenario

 0073: 

 0074: # DONE: Don't place a mine if it can't explode before the time runs out

 0075: 

 0076: # DONE: Dump mines if it can hit stuff right before the end of the scenario

 0077: 

 0078: # DONE: Check for time running out condition to handle stuff like that better

 0079: 

 0080: # cython: language_level=3

 0081: from libc.math cimport sin, cos, sqrt, fabs, atan2, acos, asin, pi, NAN, INFINITY, isnan, isinf, copysign, exp

+0082: from math import ceil, floor

  __pyx_t_2 = __Pyx_PyList_Pack(2, __pyx_mstate_global->__pyx_n_u_ceil, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_math, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ceil); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ceil, __pyx_t_2) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_floor, __pyx_t_2) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0083: from libc.stdint cimport int64_t

 0084: ctypedef double float64_t

+0085: import math

  __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_math, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_math, __pyx_t_3) < 0) __PYX_ERR(0, 85, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0086: cimport cython

 0087: 

 0088: 

 0089: 

 0090: 

+0091: import bisect

  __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_bisect, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bisect, __pyx_t_3) < 0) __PYX_ERR(0, 91, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0092: import gc

  __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_gc, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_gc, __pyx_t_3) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0093: import math

  __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_math, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 93, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_math, __pyx_t_3) < 0) __PYX_ERR(0, 93, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0094: import random

  __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_random, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_random, __pyx_t_3) < 0) __PYX_ERR(0, 94, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0095: import time

  __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_time, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_time, __pyx_t_3) < 0) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0096: from immutabledict import immutabledict

  __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_immutabledict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_immutabledict, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_immutabledict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_immutabledict, __pyx_t_3) < 0) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0097: from collections import deque

  __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_deque, __pyx_t_2) < 0) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0098: from functools import lru_cache

  __pyx_t_3 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_functools, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_lru_cache, __pyx_t_3) < 0) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0099: from itertools import chain

  __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_itertools, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_chain, __pyx_t_2) < 0) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0100: #from math import acos, asin, atan2, ceil, cos, exp, floor, inf, isinf, isnan, nan, pi, sin, sqrt, copysign

+0101: from typing import Any, Final, Optional, Sequence, TypedDict, cast

  __pyx_t_3 = __Pyx_PyList_Pack(6, __pyx_mstate_global->__pyx_n_u_Any, __pyx_mstate_global->__pyx_n_u_Final, __pyx_mstate_global->__pyx_n_u_Optional, __pyx_mstate_global->__pyx_n_u_Sequence, __pyx_mstate_global->__pyx_n_u_TypedDict, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_typing, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Any); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Any, __pyx_t_3) < 0) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Final); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Final, __pyx_t_3) < 0) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Optional); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Optional, __pyx_t_3) < 0) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Sequence); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Sequence, __pyx_t_3) < 0) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TypedDict, __pyx_t_3) < 0) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_cast, __pyx_t_3) < 0) __PYX_ERR(0, 101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 0102: 

+0103: import matplotlib.patches as patches  # type: ignore[import-untyped]

  __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_matplotlib_patches, __pyx_mstate_global->__pyx_tuple[30]); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_patches, __pyx_t_2) < 0) __PYX_ERR(0, 103, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[30] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_matplotlib, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_mstate_global->__pyx_tuple[30])) __PYX_ERR(0, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[30]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[30]);

+0104: import matplotlib.pyplot as plt  # type: ignore[import-untyped]

  __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_matplotlib_pyplot, __pyx_mstate_global->__pyx_tuple[31]); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_plt, __pyx_t_2) < 0) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[31] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_matplotlib, __pyx_mstate_global->__pyx_n_u_pyplot); if (unlikely(!__pyx_mstate_global->__pyx_tuple[31])) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[31]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[31]);

+0105: from numpy import arange, fmax, linspace, vectorize

  __pyx_t_2 = __Pyx_PyList_Pack(4, __pyx_mstate_global->__pyx_n_u_arange, __pyx_mstate_global->__pyx_n_u_fmax, __pyx_mstate_global->__pyx_n_u_linspace, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_arange, __pyx_t_2) < 0) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_fmax); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_fmax, __pyx_t_2) < 0) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_linspace); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_linspace, __pyx_t_2) < 0) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_vectorize, __pyx_t_2) < 0) __PYX_ERR(0, 105, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0106: #from mypy_extensions import i64

+0107: from skfuzzy import control, trimf  # type: ignore[import-untyped]

  __pyx_t_3 = __Pyx_PyList_Pack(2, __pyx_mstate_global->__pyx_n_u_control, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_skfuzzy, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_control, __pyx_t_3) < 0) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_trimf, __pyx_t_3) < 0) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 0108: 

 0109: #from src.kesslergame import KesslerController  # type: ignore[import-untyped]

 0110: #from kesslergame import KesslerController  # type: ignore[import-untyped]

 0111: 

 0112: # IMPORTANT: if multiple scenarios are run back-to-back, this controller doesn't get freshly initialized in the subsequent runs.

 0113: # If any global variables are changed during execution, make sure to reset them when the timestep is 0.

 0114: 

 0115: #BUILD_NUMBER: Final = "2024-06-17 Neo - Jie Fan (jie.f@pm.me)"

 0116: 

 0117: # Output config

+0118: DEBUG_MODE: Final[bool] = False

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DEBUG_MODE, Py_False) < 0) __PYX_ERR(0, 118, __pyx_L1_error)

+0119: PRINT_EXPLANATIONS: Final[bool] = False

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PRINT_EXPLANATIONS, Py_False) < 0) __PYX_ERR(0, 119, __pyx_L1_error)

+0120: EXPLANATION_MESSAGE_SILENCE_INTERVAL_S: Final[float] = 2.0  # Repeated messages within this time window get silenced

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EXPLANATION_MESSAGE_SILENCE_INTE, __pyx_mstate_global->__pyx_float_2_0) < 0) __PYX_ERR(0, 120, __pyx_L1_error)

 0121: 

 0122: # These can trade off to get better performance at the expense of safety

 0123: # TRUE FOR COMPETITION, inexpensive

+0124: STATE_CONSISTENCY_CHECK_AND_RECOVERY = True  # Enable this if we want to be able to recover from controller exceptions

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STATE_CONSISTENCY_CHECK_AND_RECO, Py_True) < 0) __PYX_ERR(0, 124, __pyx_L1_error)

 0125: # TRUE FOR COMPETITION, inexpensive

+0126: CLEAN_UP_STATE_FOR_SUBSEQUENT_SCENARIO_RUNS = True  # If NeoController is only instantiated once and run through multiple scenarios, this must be on!

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CLEAN_UP_STATE_FOR_SUBSEQUENT_SC, Py_True) < 0) __PYX_ERR(0, 126, __pyx_L1_error)

 0127: # FALSE FOR COMPETITION, slight performance hit

+0128: ENABLE_SANITY_CHECKS: Final[bool] = False  # Miscellaneous sanity checks throughout the code

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS, Py_False) < 0) __PYX_ERR(0, 128, __pyx_L1_error)

 0129: # TRUE FOR COMPETITION, performance boost

+0130: PRUNE_SIM_STATE_SEQUENCE: Final[bool] = True  # Good to have on, because we don't really need the full state

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PRUNE_SIM_STATE_SEQUENCE, Py_True) < 0) __PYX_ERR(0, 130, __pyx_L1_error)

 0131: # FALSE FOR COMPETITION, slight performance hit

+0132: VALIDATE_SIMULATED_KEY_STATES: Final[bool] = False  # Check for desyncs between Kessler and Neo's internal simulation of the game

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VALIDATE_SIMULATED_KEY_STATES, Py_False) < 0) __PYX_ERR(0, 132, __pyx_L1_error)

 0133: # FALSE FOR COMPETITION, major performance hit

+0134: VALIDATE_ALL_SIMULATED_STATES: Final[bool] = False  # Super meticulous check for desyncs. This is very slow! Not recommended, since just verifying the key states will catch desyncs eventually. This is only good for if you need to know exactly when the desync occurred.

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VALIDATE_ALL_SIMULATED_STATES, Py_False) < 0) __PYX_ERR(0, 134, __pyx_L1_error)

 0135: # FALSE FOR COMPETITION, major performance hit

+0136: VERIFY_AST_TRACKING: Final[bool] = False  # I'm using a very error prone way to track asteroids, where I very easily get the time of the asteroid wrong. This will check to make sure the times aren't mismatched, by checking whether the asteroid we're looking for appears in the wrong timestep.

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VERIFY_AST_TRACKING, Py_False) < 0) __PYX_ERR(0, 136, __pyx_L1_error)

 0137: 

+0138: RESEED_RNG: Final[bool] = True # If the random seed was set outside of Neo, this will reseed the RNG to ensure good randomness

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RESEED_RNG, Py_True) < 0) __PYX_ERR(0, 138, __pyx_L1_error)

 0139: 

 0140: # Strategic variables

+0141: END_OF_SCENARIO_DONT_CARE_TIMESTEPS: Final[int] = 8

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_END_OF_SCENARIO_DONT_CARE_TIMEST, __pyx_mstate_global->__pyx_int_8) < 0) __PYX_ERR(0, 141, __pyx_L1_error)

+0142: ADVERSARY_ROTATION_TIMESTEP_FUDGE: Final[int] = 20  # Since we can't predict the adversary ship, in the targetting frontrun protection, fudge the adversary's ship to be more conservative. Since we predict they don't move, but they could be aiming toward the target.

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADVERSARY_ROTATION_TIMESTEP_FUDG, __pyx_mstate_global->__pyx_int_20) < 0) __PYX_ERR(0, 142, __pyx_L1_error)

 0143: # TODO: Actually wait, doesn't the rotation timestep fudge just need to be 5, because each stationary targetting is just 5 timesteps long? So using 20 may be overkill!

+0144: UNWRAP_ASTEROID_COLLISION_FORECAST_TIME_HORIZON: Final[float] = 8.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_UNWRAP_ASTEROID_COLLISION_FORECA, __pyx_mstate_global->__pyx_float_8_0) < 0) __PYX_ERR(0, 144, __pyx_L1_error)

+0145: UNWRAP_ASTEROID_TARGET_SELECTION_TIME_HORIZON: Final[float] = 2.3 # The upper bound would be sqrt(1000.0**2 + 800.0**2)/800.0 + 1.0 = 2.600781059358212 s, which is 1 second to turn and the rest for bullet travel time. But this is the worst case scenario. In most cases, we don't need this much.

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_UNWRAP_ASTEROID_TARGET_SELECTION, __pyx_mstate_global->__pyx_float_2_3) < 0) __PYX_ERR(0, 145, __pyx_L1_error)

+0146: ASTEROID_SIZE_SHOT_PRIORITY: Final = (NAN, 1, 2, 3, 4)  # Index i holds the priority of shooting an asteroid of size i (the first element is not important)

  __pyx_t_2 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_Pack(5, __pyx_t_2, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_int_3, __pyx_mstate_global->__pyx_int_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROID_SIZE_SHOT_PRIORITY, __pyx_t_3) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0147: fitness_function_weights: Optional[tuple[float, float, float, float, float, float, float, float, float]] = None

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_fitness_function_weights, Py_None) < 0) __PYX_ERR(0, 147, __pyx_L1_error)

+0148: MINE_DROP_COOLDOWN_FUDGE_TS: Final[int] = 61  # We can drop a mine every 30 timesteps. But it's better to wait a bit longer between mines, so then if I drop two and the first one blows me up, I have time to get out of the radius of the second blast!

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_DROP_COOLDOWN_FUDGE_TS, __pyx_mstate_global->__pyx_int_61) < 0) __PYX_ERR(0, 148, __pyx_L1_error)

+0149: MINE_ASTEROID_COUNT_FUDGE_DISTANCE: Final[float] = 50.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_ASTEROID_COUNT_FUDGE_DISTAN, __pyx_mstate_global->__pyx_float_50_0) < 0) __PYX_ERR(0, 149, __pyx_L1_error)

+0150: MINE_OPPORTUNITY_CHECK_INTERVAL_TS: Final[int] = 10

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_OPPORTUNITY_CHECK_INTERVAL, __pyx_mstate_global->__pyx_int_10) < 0) __PYX_ERR(0, 150, __pyx_L1_error)

+0151: MINE_OTHER_SHIP_RADIUS_FUDGE: Final[float] = 40.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_OTHER_SHIP_RADIUS_FUDGE, __pyx_mstate_global->__pyx_float_40_0) < 0) __PYX_ERR(0, 151, __pyx_L1_error)

+0152: MINE_OTHER_SHIP_ASTEROID_COUNT_EQUIVALENT: Final[int] = 10

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_OTHER_SHIP_ASTEROID_COUNT_E, __pyx_mstate_global->__pyx_int_10) < 0) __PYX_ERR(0, 152, __pyx_L1_error)

+0153: TARGETING_AIMING_UNDERTURN_ALLOWANCE_DEG: Final[float] = 6.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TARGETING_AIMING_UNDERTURN_ALLOW, __pyx_mstate_global->__pyx_float_6_0) < 0) __PYX_ERR(0, 153, __pyx_L1_error)

 0154: # (asteroid_safe_time_fitness, mine_safe_time_fitness, asteroids_fitness, sequence_length_fitness, other_ship_proximity_fitness, crash_fitness, asteroid_aiming_cone_fitness, placed_mine_fitness, overall_safe_time_fitness)

 0155: # These fitness weights were picked after doing a ton of training with a genetic optimizer:

+0156: DEFAULT_FITNESS_WEIGHTS: Final = (0.0, 0.13359801675028146, 0.1488417344765523, 0.0, 0.06974293843076491, 0.20559835937182916, 0.12775194210275548, 0.14357775694291458, 0.17088925192490204) # Hand picked: (7.0, 10.0, 1.5, 0.5, 6.0, 12.0, 0.5, 2.0, 7.0)

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DEFAULT_FITNESS_WEIGHTS, __pyx_mstate_global->__pyx_tuple[32]) < 0) __PYX_ERR(0, 156, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[32] = PyTuple_Pack(9, __pyx_mstate_global->__pyx_float_0_0, __pyx_mstate_global->__pyx_float_0_13359801675028146, __pyx_mstate_global->__pyx_float_0_1488417344765523, __pyx_mstate_global->__pyx_float_0_0, __pyx_mstate_global->__pyx_float_0_06974293843076491, __pyx_mstate_global->__pyx_float_0_20559835937182916, __pyx_mstate_global->__pyx_float_0_12775194210275548, __pyx_mstate_global->__pyx_float_0_14357775694291458, __pyx_mstate_global->__pyx_float_0_17088925192490204); if (unlikely(!__pyx_mstate_global->__pyx_tuple[32])) __PYX_ERR(0, 156, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[32]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[32]);

+0157: MANEUVER_CONVENIENT_SHOT_CHECKER_CONE_WIDTH_ANGLE_HALF: Final[float] = 45.0  # I'd expect the smaller this is, the faster. But apparently 30 can be slower than 45 for some reason. So I'll leave it on 45 lol

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MANEUVER_CONVENIENT_SHOT_CHECKER_2, __pyx_mstate_global->__pyx_float_45_0) < 0) __PYX_ERR(0, 157, __pyx_L1_error)

+0158: MANEUVER_CONVENIENT_SHOT_CHECKER_CONE_WIDTH_ANGLE_HALF_COSINE: Final[float] = cos(math.radians(MANEUVER_CONVENIENT_SHOT_CHECKER_CONE_WIDTH_ANGLE_HALF))

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MANEUVER_CONVENIENT_SHOT_CHECKER_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 158, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(cos(__pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MANEUVER_CONVENIENT_SHOT_CHECKER, __pyx_t_3) < 0) __PYX_ERR(0, 158, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0159: MANEUVER_BULLET_SIM_CULLING_CONE_WIDTH_ANGLE_HALF: Final[float] = 60.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MANEUVER_BULLET_SIM_CULLING_CONE_2, __pyx_mstate_global->__pyx_float_60_0) < 0) __PYX_ERR(0, 159, __pyx_L1_error)

+0160: MANEUVER_BULLET_SIM_CULLING_CONE_WIDTH_ANGLE_HALF_COSINE: Final[float] = cos(math.radians(MANEUVER_BULLET_SIM_CULLING_CONE_WIDTH_ANGLE_HALF))

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MANEUVER_BULLET_SIM_CULLING_CONE_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(cos(__pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MANEUVER_BULLET_SIM_CULLING_CONE, __pyx_t_3) < 0) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0161: MAX_CRUISE_TIMESTEPS: Final[float] = 30.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAX_CRUISE_TIMESTEPS, __pyx_mstate_global->__pyx_float_30_0) < 0) __PYX_ERR(0, 161, __pyx_L1_error)

+0162: MANEUVER_TUPLE_LEARNING_ROLLING_AVERAGE_PERIOD: Final[int] = 10

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MANEUVER_TUPLE_LEARNING_ROLLING, __pyx_mstate_global->__pyx_int_10) < 0) __PYX_ERR(0, 162, __pyx_L1_error)

+0163: OVERALL_FITNESS_ROLLING_AVERAGE_PERIOD: Final[int] = 5

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OVERALL_FITNESS_ROLLING_AVERAGE, __pyx_mstate_global->__pyx_int_5) < 0) __PYX_ERR(0, 163, __pyx_L1_error)

+0164: AIMING_CONE_FITNESS_CONE_WIDTH_HALF: Final[float] = 18.0 # This has to do with how fast we turn vs how often we can shoot. This can be thought of as some percentage of DEGREES_BETWEEN_SHOTS defined later

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AIMING_CONE_FITNESS_CONE_WIDTH_H_2, __pyx_mstate_global->__pyx_float_18_0) < 0) __PYX_ERR(0, 164, __pyx_L1_error)

+0165: AIMING_CONE_FITNESS_CONE_WIDTH_HALF_COSINE: Final[float] = cos(math.radians(AIMING_CONE_FITNESS_CONE_WIDTH_HALF))

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_AIMING_CONE_FITNESS_CONE_WIDTH_H_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(cos(__pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AIMING_CONE_FITNESS_CONE_WIDTH_H, __pyx_t_3) < 0) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0166: MANEUVER_SIM_DISALLOW_TARGETING_FOR_START_TIMESTEPS_AMOUNT: Final[int] = 10

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MANEUVER_SIM_DISALLOW_TARGETING, __pyx_mstate_global->__pyx_int_10) < 0) __PYX_ERR(0, 166, __pyx_L1_error)

+0167: ASTEROID_AIM_BUFFER_PIXELS: Final[float] = 1.0  # px

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROID_AIM_BUFFER_PIXELS, __pyx_mstate_global->__pyx_float_1_0) < 0) __PYX_ERR(0, 167, __pyx_L1_error)

+0168: COORDINATE_BOUND_CHECK_PADDING: Final[float] = 1.0  # px

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COORDINATE_BOUND_CHECK_PADDING, __pyx_mstate_global->__pyx_float_1_0) < 0) __PYX_ERR(0, 168, __pyx_L1_error)

+0169: SHIP_AVOIDANCE_PADDING: Final = 25

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_AVOIDANCE_PADDING, __pyx_mstate_global->__pyx_int_25) < 0) __PYX_ERR(0, 169, __pyx_L1_error)

+0170: SHIP_AVOIDANCE_SPEED_PADDING_RATIO: Final[float] = 1/100

  __pyx_t_3 = PyFloat_FromDouble((1.0 / 100.0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_AVOIDANCE_SPEED_PADDING_RAT, __pyx_t_3) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0171: PERFORMANCE_CONTROLLER_ROLLING_AVERAGE_FRAME_INTERVAL: Final[int] = 10

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PERFORMANCE_CONTROLLER_ROLLING_A, __pyx_mstate_global->__pyx_int_10) < 0) __PYX_ERR(0, 171, __pyx_L1_error)

+0172: RANDOM_WALK_SCHEDULE_LENGTH: Final[int] = 3 # However many shots to plan out the direction for. Any shots after this, there isn't a limitation on direction.

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RANDOM_WALK_SCHEDULE_LENGTH, __pyx_mstate_global->__pyx_int_3) < 0) __PYX_ERR(0, 172, __pyx_L1_error)

 0173: # The reason we need this, is because without it, I'm checking whether I have the budget to do another iteration, but let's say I'm already taking 0 time. Kessler will pause for DELTA_TIME, taking up all the time, and I'd think I have no time to do anything!

 0174: # So this fudge allows us to "push things" a bit, and fill up any remaining time so that Kessler is no longer pausing, and that time is spent in this controller to do more computations.

 0175: # The side effect is that if we set this multiplier too low, then we're going to be operating at less than real time for sure.

 0176: # Going slightly slower than real time is expected, since we always need to push things to know where that limit is

 0177: # This isn't needed if the realtime multiplier is set to 0 within Kessler, so that Kessler is not unnecessarily pausing and running as fast as it can. But with realtime multiplier at 1, this is needed.

 0178: # If realtime multiplier is set to some wacky value above 1, the game won't speed up and Neo will just use that time to do more iterations! To fix that, we need to change this multiplier to be above 1 too

 0179: # You can kind of think of this as the percentage of real time we're going at. Kinda...

 0180: # Also my logic is that if I always make sure I have enough time, then I’ll actually be within budget. Because say I take 10 time to do something. Well if I have 10 time left, I do it, but anything from 9 to 0 time left, I don’t. So on average, I leave out 10/2 time on the table. So that’s why I set the fudge multiplier to 0.5, so things average out to me being exactly on budget.

+0181: PERFORMANCE_CONTROLLER_PUSHING_THE_ENVELOPE_FUDGE_MULTIPLIER: Final[float] = 0.55

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PERFORMANCE_CONTROLLER_PUSHING_T, __pyx_mstate_global->__pyx_float_0_55) < 0) __PYX_ERR(0, 181, __pyx_L1_error)

+0182: MINIMUM_DELTA_TIME_FRACTION_BUDGET: Final[float] = 0.55 # One frametime is 1.0. If we give the other ship half of the time, then we should set this to 0.5. If we want non-realtime performance, we can change this to be >1

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINIMUM_DELTA_TIME_FRACTION_BUDG, __pyx_mstate_global->__pyx_float_0_55) < 0) __PYX_ERR(0, 182, __pyx_L1_error)

+0183: ENABLE_PERFORMANCE_CONTROLLER: Final[bool] = True  # The performance controller uses realtime, so it's nondeterministic. For debugging and using set random seeds, turn this off so the controller is determinstic again

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ENABLE_PERFORMANCE_CONTROLLER, Py_True) < 0) __PYX_ERR(0, 183, __pyx_L1_error)

 0184: 

 0185: # For the tuples below, the index is the number of lives Neo has left while going into the move

 0186: # Index 0 in the tuples is not used, but to be safe I put a sane number there

 0187: 

+0188: MAX_RESPAWN_PER_TIMESTEP_SEARCH_ITERATIONS: Final[int] = 100

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAX_RESPAWN_PER_TIMESTEP_SEARCH, __pyx_mstate_global->__pyx_int_100) < 0) __PYX_ERR(0, 188, __pyx_L1_error)

+0189: MAX_MANEUVER_PER_TIMESTEP_SEARCH_ITERATIONS: Final[int] = 100

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAX_MANEUVER_PER_TIMESTEP_SEARCH, __pyx_mstate_global->__pyx_int_100) < 0) __PYX_ERR(0, 189, __pyx_L1_error)

 0190: # For each row of the lookup table, the index in the row corresponds to the number of lives left, minus one

+0191: MIN_RESPAWN_PER_TIMESTEP_SEARCH_ITERATIONS_LUT: Final = ((80, 55, 14), # Fitness from 0.0 to 0.1

  __pyx_mstate_global->__pyx_tuple[33] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_80, __pyx_mstate_global->__pyx_int_55, __pyx_mstate_global->__pyx_int_14); if (unlikely(!__pyx_mstate_global->__pyx_tuple[33])) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[33]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[33]);
/* … */
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN_RESPAWN_PER_TIMESTEP_SEARCH, __pyx_mstate_global->__pyx_tuple[43]) < 0) __PYX_ERR(0, 191, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[43] = PyTuple_Pack(10, __pyx_mstate_global->__pyx_tuple[33], __pyx_mstate_global->__pyx_tuple[34], __pyx_mstate_global->__pyx_tuple[35], __pyx_mstate_global->__pyx_tuple[36], __pyx_mstate_global->__pyx_tuple[37], __pyx_mstate_global->__pyx_tuple[38], __pyx_mstate_global->__pyx_tuple[39], __pyx_mstate_global->__pyx_tuple[40], __pyx_mstate_global->__pyx_tuple[41], __pyx_mstate_global->__pyx_tuple[42]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[43])) __PYX_ERR(0, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[43]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[43]);

+0192:                                                          (70, 40, 13), # Fitness from 0.1 to 0.2

  __pyx_mstate_global->__pyx_tuple[34] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_70, __pyx_mstate_global->__pyx_int_40, __pyx_mstate_global->__pyx_int_13); if (unlikely(!__pyx_mstate_global->__pyx_tuple[34])) __PYX_ERR(0, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[34]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[34]);

+0193:                                                          (60, 28, 12), # Fitness from 0.2 to 0.3

  __pyx_mstate_global->__pyx_tuple[35] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_60, __pyx_mstate_global->__pyx_int_28, __pyx_mstate_global->__pyx_int_12); if (unlikely(!__pyx_mstate_global->__pyx_tuple[35])) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[35]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[35]);

+0194:                                                          (50, 26, 11), # Fitness from 0.3 to 0.4

  __pyx_mstate_global->__pyx_tuple[36] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_50, __pyx_mstate_global->__pyx_int_26, __pyx_mstate_global->__pyx_int_11); if (unlikely(!__pyx_mstate_global->__pyx_tuple[36])) __PYX_ERR(0, 194, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[36]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[36]);

+0195:                                                          (45, 14, 10), # Fitness from 0.4 to 0.5

  __pyx_mstate_global->__pyx_tuple[37] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_45, __pyx_mstate_global->__pyx_int_14, __pyx_mstate_global->__pyx_int_10); if (unlikely(!__pyx_mstate_global->__pyx_tuple[37])) __PYX_ERR(0, 195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[37]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[37]);

+0196:                                                          (16, 12, 9), # Fitness from 0.5 to 0.6

  __pyx_mstate_global->__pyx_tuple[38] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_int_12, __pyx_mstate_global->__pyx_int_9); if (unlikely(!__pyx_mstate_global->__pyx_tuple[38])) __PYX_ERR(0, 196, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[38]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[38]);

+0197:                                                          (15, 11, 8), # Fitness from 0.6 to 0.7

  __pyx_mstate_global->__pyx_tuple[39] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_15, __pyx_mstate_global->__pyx_int_11, __pyx_mstate_global->__pyx_int_8); if (unlikely(!__pyx_mstate_global->__pyx_tuple[39])) __PYX_ERR(0, 197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[39]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[39]);

+0198:                                                          (14, 10, 7), # Fitness from 0.7 to 0.8

  __pyx_mstate_global->__pyx_tuple[40] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_14, __pyx_mstate_global->__pyx_int_10, __pyx_mstate_global->__pyx_int_7); if (unlikely(!__pyx_mstate_global->__pyx_tuple[40])) __PYX_ERR(0, 198, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[40]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[40]);

+0199:                                                          (13, 9, 6), # Fitness from 0.8 to 0.9

  __pyx_mstate_global->__pyx_tuple[41] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_13, __pyx_mstate_global->__pyx_int_9, __pyx_mstate_global->__pyx_int_6); if (unlikely(!__pyx_mstate_global->__pyx_tuple[41])) __PYX_ERR(0, 199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[41]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[41]);

+0200:                                                          (12, 8, 5)) # Fitness from 0.9 to 1.0

  __pyx_mstate_global->__pyx_tuple[42] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_12, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_int_5); if (unlikely(!__pyx_mstate_global->__pyx_tuple[42])) __PYX_ERR(0, 200, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[42]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[42]);

+0201: MIN_RESPAWN_PER_PERIOD_SEARCH_ITERATIONS_LUT: Final = ((1000, 900, 440), # Fitness from 0.0 to 0.1

  __pyx_mstate_global->__pyx_tuple[44] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_1000, __pyx_mstate_global->__pyx_int_900, __pyx_mstate_global->__pyx_int_440); if (unlikely(!__pyx_mstate_global->__pyx_tuple[44])) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[44]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[44]);
/* … */
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN_RESPAWN_PER_PERIOD_SEARCH_IT, __pyx_mstate_global->__pyx_tuple[54]) < 0) __PYX_ERR(0, 201, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[54] = PyTuple_Pack(10, __pyx_mstate_global->__pyx_tuple[44], __pyx_mstate_global->__pyx_tuple[45], __pyx_mstate_global->__pyx_tuple[46], __pyx_mstate_global->__pyx_tuple[47], __pyx_mstate_global->__pyx_tuple[48], __pyx_mstate_global->__pyx_tuple[49], __pyx_mstate_global->__pyx_tuple[50], __pyx_mstate_global->__pyx_tuple[51], __pyx_mstate_global->__pyx_tuple[52], __pyx_mstate_global->__pyx_tuple[53]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[54])) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[54]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[54]);

+0202:                                                        (950, 810, 430), # Fitness from 0.1 to 0.2

  __pyx_mstate_global->__pyx_tuple[45] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_950, __pyx_mstate_global->__pyx_int_810, __pyx_mstate_global->__pyx_int_430); if (unlikely(!__pyx_mstate_global->__pyx_tuple[45])) __PYX_ERR(0, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[45]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[45]);

+0203:                                                        (925, 780, 420), # Fitness from 0.2 to 0.3

  __pyx_mstate_global->__pyx_tuple[46] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_925, __pyx_mstate_global->__pyx_int_780, __pyx_mstate_global->__pyx_int_420); if (unlikely(!__pyx_mstate_global->__pyx_tuple[46])) __PYX_ERR(0, 203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[46]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[46]);

+0204:                                                        (900, 730, 410), # Fitness from 0.3 to 0.4

  __pyx_mstate_global->__pyx_tuple[47] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_900, __pyx_mstate_global->__pyx_int_730, __pyx_mstate_global->__pyx_int_410); if (unlikely(!__pyx_mstate_global->__pyx_tuple[47])) __PYX_ERR(0, 204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[47]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[47]);

+0205:                                                        (850, 715, 400), # Fitness from 0.4 to 0.5

  __pyx_mstate_global->__pyx_tuple[48] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_850, __pyx_mstate_global->__pyx_int_715, __pyx_mstate_global->__pyx_int_400); if (unlikely(!__pyx_mstate_global->__pyx_tuple[48])) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[48]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[48]);

+0206:                                                        (815, 680, 390), # Fitness from 0.5 to 0.6

  __pyx_mstate_global->__pyx_tuple[49] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_815, __pyx_mstate_global->__pyx_int_680, __pyx_mstate_global->__pyx_int_390); if (unlikely(!__pyx_mstate_global->__pyx_tuple[49])) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[49]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[49]);

+0207:                                                        (790, 660, 380), # Fitness from 0.6 to 0.7

  __pyx_mstate_global->__pyx_tuple[50] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_790, __pyx_mstate_global->__pyx_int_660, __pyx_mstate_global->__pyx_int_380); if (unlikely(!__pyx_mstate_global->__pyx_tuple[50])) __PYX_ERR(0, 207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[50]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[50]);

+0208:                                                        (760, 640, 370), # Fitness from 0.7 to 0.8

  __pyx_mstate_global->__pyx_tuple[51] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_760, __pyx_mstate_global->__pyx_int_640, __pyx_mstate_global->__pyx_int_370); if (unlikely(!__pyx_mstate_global->__pyx_tuple[51])) __PYX_ERR(0, 208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[51]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[51]);

+0209:                                                        (730, 620, 360), # Fitness from 0.8 to 0.9

  __pyx_mstate_global->__pyx_tuple[52] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_730, __pyx_mstate_global->__pyx_int_620, __pyx_mstate_global->__pyx_int_360); if (unlikely(!__pyx_mstate_global->__pyx_tuple[52])) __PYX_ERR(0, 209, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[52]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[52]);

+0210:                                                        (700, 600, 350)) # Fitness from 0.9 to 1.0

  __pyx_mstate_global->__pyx_tuple[53] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_700, __pyx_mstate_global->__pyx_int_600, __pyx_mstate_global->__pyx_int_350); if (unlikely(!__pyx_mstate_global->__pyx_tuple[53])) __PYX_ERR(0, 210, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[53]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[53]);

+0211: MIN_MANEUVER_PER_TIMESTEP_SEARCH_ITERATIONS_LUT: Final = ((85, 65, 30), # Fitness from 0.0 to 0.1

  __pyx_mstate_global->__pyx_tuple[55] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_85, __pyx_mstate_global->__pyx_int_65, __pyx_mstate_global->__pyx_int_30); if (unlikely(!__pyx_mstate_global->__pyx_tuple[55])) __PYX_ERR(0, 211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[55]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[55]);
/* … */
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN_MANEUVER_PER_TIMESTEP_SEARCH, __pyx_mstate_global->__pyx_tuple[65]) < 0) __PYX_ERR(0, 211, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[65] = PyTuple_Pack(10, __pyx_mstate_global->__pyx_tuple[55], __pyx_mstate_global->__pyx_tuple[56], __pyx_mstate_global->__pyx_tuple[57], __pyx_mstate_global->__pyx_tuple[58], __pyx_mstate_global->__pyx_tuple[59], __pyx_mstate_global->__pyx_tuple[60], __pyx_mstate_global->__pyx_tuple[61], __pyx_mstate_global->__pyx_tuple[62], __pyx_mstate_global->__pyx_tuple[63], __pyx_mstate_global->__pyx_tuple[64]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[65])) __PYX_ERR(0, 211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[65]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[65]);

+0212:                                                           (65, 52, 25), # Fitness from 0.1 to 0.2

  __pyx_mstate_global->__pyx_tuple[56] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_65, __pyx_mstate_global->__pyx_int_52, __pyx_mstate_global->__pyx_int_25); if (unlikely(!__pyx_mstate_global->__pyx_tuple[56])) __PYX_ERR(0, 212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[56]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[56]);

+0213:                                                           (55, 40, 20), # Fitness from 0.2 to 0.3

  __pyx_mstate_global->__pyx_tuple[57] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_55, __pyx_mstate_global->__pyx_int_40, __pyx_mstate_global->__pyx_int_20); if (unlikely(!__pyx_mstate_global->__pyx_tuple[57])) __PYX_ERR(0, 213, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[57]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[57]);

+0214:                                                           (45, 25, 15), # Fitness from 0.3 to 0.4

  __pyx_mstate_global->__pyx_tuple[58] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_45, __pyx_mstate_global->__pyx_int_25, __pyx_mstate_global->__pyx_int_15); if (unlikely(!__pyx_mstate_global->__pyx_tuple[58])) __PYX_ERR(0, 214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[58]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[58]);

+0215:                                                           (25, 12, 9), # Fitness from 0.4 to 0.5

  __pyx_mstate_global->__pyx_tuple[59] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_25, __pyx_mstate_global->__pyx_int_12, __pyx_mstate_global->__pyx_int_9); if (unlikely(!__pyx_mstate_global->__pyx_tuple[59])) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[59]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[59]);

+0216:                                                           (20, 9, 6), # Fitness from 0.5 to 0.6

  __pyx_mstate_global->__pyx_tuple[60] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_20, __pyx_mstate_global->__pyx_int_9, __pyx_mstate_global->__pyx_int_6); if (unlikely(!__pyx_mstate_global->__pyx_tuple[60])) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[60]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[60]);

+0217:                                                           (14, 7, 5), # Fitness from 0.6 to 0.7

  __pyx_mstate_global->__pyx_tuple[61] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_14, __pyx_mstate_global->__pyx_int_7, __pyx_mstate_global->__pyx_int_5); if (unlikely(!__pyx_mstate_global->__pyx_tuple[61])) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[61]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[61]);

+0218:                                                           (8, 5, 4), # Fitness from 0.7 to 0.8

  __pyx_mstate_global->__pyx_tuple[62] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_int_5, __pyx_mstate_global->__pyx_int_4); if (unlikely(!__pyx_mstate_global->__pyx_tuple[62])) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[62]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[62]);

+0219:                                                           (7, 4, 3), # Fitness from 0.8 to 0.9

  __pyx_mstate_global->__pyx_tuple[63] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_7, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_int_3); if (unlikely(!__pyx_mstate_global->__pyx_tuple[63])) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[63]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[63]);

+0220:                                                           (6, 3, 2)) # Fitness from 0.9 to 1.0

  __pyx_mstate_global->__pyx_tuple[64] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_6, __pyx_mstate_global->__pyx_int_3, __pyx_mstate_global->__pyx_int_2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[64])) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[64]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[64]);

+0221: MIN_MANEUVER_PER_PERIOD_SEARCH_ITERATIONS_LUT = ((300, 230, 105), # Fitness from 0.0 to 0.1

  __pyx_mstate_global->__pyx_tuple[66] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_300, __pyx_mstate_global->__pyx_int_230, __pyx_mstate_global->__pyx_int_105); if (unlikely(!__pyx_mstate_global->__pyx_tuple[66])) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[66]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[66]);
/* … */
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN_MANEUVER_PER_PERIOD_SEARCH_I, __pyx_mstate_global->__pyx_tuple[76]) < 0) __PYX_ERR(0, 221, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[76] = PyTuple_Pack(10, __pyx_mstate_global->__pyx_tuple[66], __pyx_mstate_global->__pyx_tuple[67], __pyx_mstate_global->__pyx_tuple[68], __pyx_mstate_global->__pyx_tuple[69], __pyx_mstate_global->__pyx_tuple[70], __pyx_mstate_global->__pyx_tuple[71], __pyx_mstate_global->__pyx_tuple[72], __pyx_mstate_global->__pyx_tuple[73], __pyx_mstate_global->__pyx_tuple[74], __pyx_mstate_global->__pyx_tuple[75]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[76])) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[76]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[76]);

+0222:                                                  (230, 185, 88), # Fitness from 0.1 to 0.2

  __pyx_mstate_global->__pyx_tuple[67] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_230, __pyx_mstate_global->__pyx_int_185, __pyx_mstate_global->__pyx_int_88); if (unlikely(!__pyx_mstate_global->__pyx_tuple[67])) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[67]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[67]);

+0223:                                                  (193, 140, 70), # Fitness from 0.2 to 0.3

  __pyx_mstate_global->__pyx_tuple[68] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_193, __pyx_mstate_global->__pyx_int_140, __pyx_mstate_global->__pyx_int_70); if (unlikely(!__pyx_mstate_global->__pyx_tuple[68])) __PYX_ERR(0, 223, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[68]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[68]);

+0224:                                                  (160, 88, 55), # Fitness from 0.3 to 0.4

  __pyx_mstate_global->__pyx_tuple[69] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_160, __pyx_mstate_global->__pyx_int_88, __pyx_mstate_global->__pyx_int_55); if (unlikely(!__pyx_mstate_global->__pyx_tuple[69])) __PYX_ERR(0, 224, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[69]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[69]);

+0225:                                                  (88, 42, 32), # Fitness from 0.4 to 0.5

  __pyx_mstate_global->__pyx_tuple[70] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_88, __pyx_mstate_global->__pyx_int_42, __pyx_mstate_global->__pyx_int_32); if (unlikely(!__pyx_mstate_global->__pyx_tuple[70])) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[70]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[70]);

+0226:                                                  (56, 28, 21), # Fitness from 0.5 to 0.6

  __pyx_mstate_global->__pyx_tuple[71] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_56, __pyx_mstate_global->__pyx_int_28, __pyx_mstate_global->__pyx_int_21); if (unlikely(!__pyx_mstate_global->__pyx_tuple[71])) __PYX_ERR(0, 226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[71]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[71]);

+0227:                                                  (35, 25, 18), # Fitness from 0.6 to 0.7

  __pyx_mstate_global->__pyx_tuple[72] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_35, __pyx_mstate_global->__pyx_int_25, __pyx_mstate_global->__pyx_int_18); if (unlikely(!__pyx_mstate_global->__pyx_tuple[72])) __PYX_ERR(0, 227, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[72]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[72]);

+0228:                                                  (25, 18, 14), # Fitness from 0.7 to 0.8

  __pyx_mstate_global->__pyx_tuple[73] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_25, __pyx_mstate_global->__pyx_int_18, __pyx_mstate_global->__pyx_int_14); if (unlikely(!__pyx_mstate_global->__pyx_tuple[73])) __PYX_ERR(0, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[73]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[73]);

+0229:                                                  (14, 11, 10), # Fitness from 0.8 to 0.9

  __pyx_mstate_global->__pyx_tuple[74] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_14, __pyx_mstate_global->__pyx_int_11, __pyx_mstate_global->__pyx_int_10); if (unlikely(!__pyx_mstate_global->__pyx_tuple[74])) __PYX_ERR(0, 229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[74]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[74]);

+0230:                                                  (11, 11, 7)) # Fitness from 0.9 to 1.0

  __pyx_mstate_global->__pyx_tuple[75] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_11, __pyx_mstate_global->__pyx_int_11, __pyx_mstate_global->__pyx_int_7); if (unlikely(!__pyx_mstate_global->__pyx_tuple[75])) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[75]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[75]);

+0231: MIN_MANEUVER_PER_PERIOD_SEARCH_ITERATIONS_IF_WILL_DIE_LUT = ((860, 680, 340), # Fitness from 0.0 to 0.1

  __pyx_mstate_global->__pyx_tuple[77] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_860, __pyx_mstate_global->__pyx_int_680, __pyx_mstate_global->__pyx_int_340); if (unlikely(!__pyx_mstate_global->__pyx_tuple[77])) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[77]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[77]);
/* … */
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN_MANEUVER_PER_PERIOD_SEARCH_I_2, __pyx_mstate_global->__pyx_tuple[87]) < 0) __PYX_ERR(0, 231, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[87] = PyTuple_Pack(10, __pyx_mstate_global->__pyx_tuple[77], __pyx_mstate_global->__pyx_tuple[78], __pyx_mstate_global->__pyx_tuple[79], __pyx_mstate_global->__pyx_tuple[80], __pyx_mstate_global->__pyx_tuple[81], __pyx_mstate_global->__pyx_tuple[82], __pyx_mstate_global->__pyx_tuple[83], __pyx_mstate_global->__pyx_tuple[84], __pyx_mstate_global->__pyx_tuple[85], __pyx_mstate_global->__pyx_tuple[86]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[87])) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[87]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[87]);

+0232:                                                              (830, 660, 330), # Fitness from 0.1 to 0.2

  __pyx_mstate_global->__pyx_tuple[78] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_830, __pyx_mstate_global->__pyx_int_660, __pyx_mstate_global->__pyx_int_330); if (unlikely(!__pyx_mstate_global->__pyx_tuple[78])) __PYX_ERR(0, 232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[78]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[78]);

+0233:                                                              (800, 640, 320), # Fitness from 0.2 to 0.3

  __pyx_mstate_global->__pyx_tuple[79] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_800, __pyx_mstate_global->__pyx_int_640, __pyx_mstate_global->__pyx_int_320); if (unlikely(!__pyx_mstate_global->__pyx_tuple[79])) __PYX_ERR(0, 233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[79]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[79]);

+0234:                                                              (770, 620, 310), # Fitness from 0.3 to 0.4

  __pyx_mstate_global->__pyx_tuple[80] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_770, __pyx_mstate_global->__pyx_int_620, __pyx_mstate_global->__pyx_int_310); if (unlikely(!__pyx_mstate_global->__pyx_tuple[80])) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[80]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[80]);

+0235:                                                              (740, 600, 300), # Fitness from 0.4 to 0.5

  __pyx_mstate_global->__pyx_tuple[81] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_740, __pyx_mstate_global->__pyx_int_600, __pyx_mstate_global->__pyx_int_300); if (unlikely(!__pyx_mstate_global->__pyx_tuple[81])) __PYX_ERR(0, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[81]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[81]);

+0236:                                                              (710, 580, 290), # Fitness from 0.5 to 0.6

  __pyx_mstate_global->__pyx_tuple[82] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_710, __pyx_mstate_global->__pyx_int_580, __pyx_mstate_global->__pyx_int_290); if (unlikely(!__pyx_mstate_global->__pyx_tuple[82])) __PYX_ERR(0, 236, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[82]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[82]);

+0237:                                                              (690, 560, 280), # Fitness from 0.6 to 0.7

  __pyx_mstate_global->__pyx_tuple[83] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_690, __pyx_mstate_global->__pyx_int_560, __pyx_mstate_global->__pyx_int_280); if (unlikely(!__pyx_mstate_global->__pyx_tuple[83])) __PYX_ERR(0, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[83]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[83]);

+0238:                                                              (660, 540, 270), # Fitness from 0.7 to 0.8

  __pyx_mstate_global->__pyx_tuple[84] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_660, __pyx_mstate_global->__pyx_int_540, __pyx_mstate_global->__pyx_int_270); if (unlikely(!__pyx_mstate_global->__pyx_tuple[84])) __PYX_ERR(0, 238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[84]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[84]);

+0239:                                                              (630, 520, 260), # Fitness from 0.8 to 0.9

  __pyx_mstate_global->__pyx_tuple[85] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_630, __pyx_mstate_global->__pyx_int_520, __pyx_mstate_global->__pyx_int_260); if (unlikely(!__pyx_mstate_global->__pyx_tuple[85])) __PYX_ERR(0, 239, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[85]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[85]);

+0240:                                                              (600, 500, 250)) # Fitness from 0.9 to 1.0

  __pyx_mstate_global->__pyx_tuple[86] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_600, __pyx_mstate_global->__pyx_int_500, __pyx_mstate_global->__pyx_int_250); if (unlikely(!__pyx_mstate_global->__pyx_tuple[86])) __PYX_ERR(0, 240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[86]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[86]);

 0241: 

 0242: # State dumping for debug

+0243: PLOT_MANEUVER_TRACES: Final[bool] = False # For each planning period, plot out the traces showing where the maneuvers went for the sims

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLOT_MANEUVER_TRACES, Py_False) < 0) __PYX_ERR(0, 243, __pyx_L1_error)

+0244: PLOT_MANEUVER_MIN_TRACE_FOR_PLOT: Final[int] = 30 # If the number of traces for the planning period is below this, plotting will be skipped

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLOT_MANEUVER_MIN_TRACE_FOR_PLOT, __pyx_mstate_global->__pyx_int_30) < 0) __PYX_ERR(0, 244, __pyx_L1_error)

+0245: REALITY_STATE_DUMP: Final[bool] = False  # Dump each game state to json

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_REALITY_STATE_DUMP, Py_False) < 0) __PYX_ERR(0, 245, __pyx_L1_error)

+0246: SIMULATION_STATE_DUMP: Final[bool] = False  # Dump each simulated game state to json

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SIMULATION_STATE_DUMP, Py_False) < 0) __PYX_ERR(0, 246, __pyx_L1_error)

+0247: KEY_STATE_DUMP: Final[bool] = False  # Dump only key (base) states to json

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_KEY_STATE_DUMP, Py_False) < 0) __PYX_ERR(0, 247, __pyx_L1_error)

+0248: GAMESTATE_PLOTTING = False  # For whatever reason having this set to final gives a mypyc compilation error

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_GAMESTATE_PLOTTING, Py_False) < 0) __PYX_ERR(0, 248, __pyx_L1_error)

+0249: BULLET_SIM_PLOTTING: Final[bool] = False

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BULLET_SIM_PLOTTING, Py_False) < 0) __PYX_ERR(0, 249, __pyx_L1_error)

+0250: NEXT_TARGET_PLOTTING = False  # For whatever reason having this set to final gives a mypyc compilation error

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NEXT_TARGET_PLOTTING, Py_False) < 0) __PYX_ERR(0, 250, __pyx_L1_error)

+0251: MANEUVER_SIM_PLOTTING: Final[bool] = False

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MANEUVER_SIM_PLOTTING, Py_False) < 0) __PYX_ERR(0, 251, __pyx_L1_error)

+0252: START_GAMESTATE_PLOTTING_AT_SECOND: Final[float] = 0.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 252, __pyx_L1_error)

+0253: NEW_TARGET_PLOT_PAUSE_TIME_S: Final[float] = 0.5

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NEW_TARGET_PLOT_PAUSE_TIME_S, __pyx_mstate_global->__pyx_float_0_5) < 0) __PYX_ERR(0, 253, __pyx_L1_error)

+0254: SLOW_DOWN_GAME_AFTER_SECOND: Final[float] = INFINITY

  __pyx_t_3 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SLOW_DOWN_GAME_AFTER_SECOND, __pyx_t_3) < 0) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0255: SLOW_DOWN_GAME_PAUSE_TIME: Final[float] = 2.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SLOW_DOWN_GAME_PAUSE_TIME, __pyx_mstate_global->__pyx_float_2_0) < 0) __PYX_ERR(0, 255, __pyx_L1_error)

 0256: 

 0257: # Debug settings

+0258: ENABLE_BAD_LUCK_EXCEPTION = False

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ENABLE_BAD_LUCK_EXCEPTION, Py_False) < 0) __PYX_ERR(0, 258, __pyx_L1_error)

+0259: BAD_LUCK_EXCEPTION_PROBABILITY = 0.001

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BAD_LUCK_EXCEPTION_PROBABILITY, __pyx_mstate_global->__pyx_float_0_001) < 0) __PYX_ERR(0, 259, __pyx_L1_error)

 0260: 

 0261: # Quantities

+0262: cdef double TAD = 0.1

  __pyx_v_14neo_controller_TAD = 0.1;

+0263: cdef double GRAIN = 0.001

  __pyx_v_14neo_controller_GRAIN = 0.001;

+0264: cdef double EPS = 0.0000000001

  __pyx_v_14neo_controller_EPS = 0.0000000001;

+0265: INT_NEG_INF: Final[int] = -1000000

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF, __pyx_mstate_global->__pyx_int_neg_1000000) < 0) __PYX_ERR(0, 265, __pyx_L1_error)

+0266: INT_INF: Final[int] = 1000000

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INT_INF, __pyx_mstate_global->__pyx_int_1000000) < 0) __PYX_ERR(0, 266, __pyx_L1_error)

 0267: 

+0268: cdef double RAD_TO_DEG = 180.0/pi

  if (unlikely(M_PI == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 268, __pyx_L1_error)
  }
  __pyx_v_14neo_controller_RAD_TO_DEG = (180.0 / ((double)M_PI));

+0269: cdef double DEG_TO_RAD = pi/180.0

  __pyx_v_14neo_controller_DEG_TO_RAD = (((double)M_PI) / 180.0);

+0270: cdef double TAU = 2.0*pi

  __pyx_v_14neo_controller_TAU = (2.0 * M_PI);

 0271: 

 0272: # Kessler game constants

+0273: FIRE_COOLDOWN_TS: Final[int] = 3

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_FIRE_COOLDOWN_TS, __pyx_mstate_global->__pyx_int_3) < 0) __PYX_ERR(0, 273, __pyx_L1_error)

+0274: MINE_COOLDOWN_TS: Final[int] = 30

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_COOLDOWN_TS, __pyx_mstate_global->__pyx_int_30) < 0) __PYX_ERR(0, 274, __pyx_L1_error)

+0275: FPS: Final[float] = 30.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_FPS, __pyx_mstate_global->__pyx_float_30_0) < 0) __PYX_ERR(0, 275, __pyx_L1_error)

+0276: DELTA_TIME: Final[float] = 1/FPS  # s/ts

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DELTA_TIME, __pyx_t_5) < 0) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0277: SHIP_FIRE_TIME: Final[float] = 1/10  # seconds

  __pyx_t_5 = PyFloat_FromDouble((1.0 / 10.0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 277, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_FIRE_TIME, __pyx_t_5) < 0) __PYX_ERR(0, 277, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0278: BULLET_SPEED: Final[float] = 800.0  # px/s

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED, __pyx_mstate_global->__pyx_float_800_0) < 0) __PYX_ERR(0, 278, __pyx_L1_error)

+0279: BULLET_MASS: Final[float] = 1.0  # kg

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BULLET_MASS, __pyx_mstate_global->__pyx_float_1_0) < 0) __PYX_ERR(0, 279, __pyx_L1_error)

+0280: BULLET_LENGTH: Final[float] = 12.0  # px

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH, __pyx_mstate_global->__pyx_float_12_0) < 0) __PYX_ERR(0, 280, __pyx_L1_error)

+0281: BULLET_LENGTH_RECIPROCAL: Final[float] = 1.0/BULLET_LENGTH

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 281, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyFloat_TrueDivideCObj(__pyx_mstate_global->__pyx_float_1_0, __pyx_t_5, 1.0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 281, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH_RECIPROCAL, __pyx_t_3) < 0) __PYX_ERR(0, 281, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0282: TWICE_BULLET_LENGTH_RECIPROCAL: Final[float] = 2.0/BULLET_LENGTH

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyFloat_TrueDivideCObj(__pyx_mstate_global->__pyx_float_2_0, __pyx_t_3, 2.0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 282, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TWICE_BULLET_LENGTH_RECIPROCAL, __pyx_t_5) < 0) __PYX_ERR(0, 282, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0283: SHIP_MAX_TURN_RATE: Final[float] = 180.0  # deg/s

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE, __pyx_mstate_global->__pyx_float_180_0) < 0) __PYX_ERR(0, 283, __pyx_L1_error)

+0284: SHIP_MAX_TURN_RATE_RAD: Final[float] = math.radians(SHIP_MAX_TURN_RATE)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 284, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 284, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 284, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 284, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_RAD, __pyx_t_5) < 0) __PYX_ERR(0, 284, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0285: SHIP_MAX_TURN_RATE_RAD_RECIPROCAL: Final[float] = 1.0/SHIP_MAX_TURN_RATE_RAD

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_RAD); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 285, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyFloat_TrueDivideCObj(__pyx_mstate_global->__pyx_float_1_0, __pyx_t_5, 1.0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 285, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_RAD_RECIPROCA, __pyx_t_2) < 0) __PYX_ERR(0, 285, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0286: SHIP_MAX_TURN_RATE_DEG_TS: Final[float] = DELTA_TIME*SHIP_MAX_TURN_RATE

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_DEG_TS, __pyx_t_4) < 0) __PYX_ERR(0, 286, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0287: SHIP_MAX_TURN_RATE_RAD_TS: Final[float] = math.radians(SHIP_MAX_TURN_RATE_DEG_TS)

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 287, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_DEG_TS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 287, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_2};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_RAD_TS, __pyx_t_4) < 0) __PYX_ERR(0, 287, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0288: SHIP_MAX_THRUST: Final[float] = 480.0  # px/s^2

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST, __pyx_mstate_global->__pyx_float_480_0) < 0) __PYX_ERR(0, 288, __pyx_L1_error)

+0289: SHIP_DRAG: Final[float] = 80.0  # px/s^2

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG, __pyx_mstate_global->__pyx_float_80_0) < 0) __PYX_ERR(0, 289, __pyx_L1_error)

+0290: SHIP_MAX_SPEED: Final[float] = 240.0  # px/s

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED, __pyx_mstate_global->__pyx_float_240_0) < 0) __PYX_ERR(0, 290, __pyx_L1_error)

+0291: SHIP_RADIUS: Final[float] = 20.0  # px

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS, __pyx_mstate_global->__pyx_float_20_0) < 0) __PYX_ERR(0, 291, __pyx_L1_error)

+0292: SHIP_MASS: Final[float] = 300.0  # kg

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_MASS, __pyx_mstate_global->__pyx_float_300_0) < 0) __PYX_ERR(0, 292, __pyx_L1_error)

+0293: TIMESTEPS_UNTIL_SHIP_ACHIEVES_MAX_SPEED: Final[int] = ceil(SHIP_MAX_SPEED/(SHIP_MAX_THRUST - SHIP_DRAG)*FPS)  # Should be 18 timesteps

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ceil); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = PyNumber_Subtract(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TIMESTEPS_UNTIL_SHIP_ACHIEVES_MA, __pyx_t_4) < 0) __PYX_ERR(0, 293, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0294: MINE_BLAST_RADIUS: Final[float] = 150.0  # px

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS, __pyx_mstate_global->__pyx_float_150_0) < 0) __PYX_ERR(0, 294, __pyx_L1_error)

+0295: MINE_RADIUS: Final[float] = 12.0  # px

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_RADIUS, __pyx_mstate_global->__pyx_float_12_0) < 0) __PYX_ERR(0, 295, __pyx_L1_error)

+0296: MINE_BLAST_PRESSURE: Final[float] = 2000.0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_PRESSURE, __pyx_mstate_global->__pyx_float_2000_0) < 0) __PYX_ERR(0, 296, __pyx_L1_error)

+0297: MINE_FUSE_TIME: Final[float] = 3.0  # s

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME, __pyx_mstate_global->__pyx_float_3_0) < 0) __PYX_ERR(0, 297, __pyx_L1_error)

+0298: MINE_MASS: Final[float] = 25.0  # kg

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINE_MASS, __pyx_mstate_global->__pyx_float_25_0) < 0) __PYX_ERR(0, 298, __pyx_L1_error)

+0299: ASTEROID_RADII_LOOKUP: Final = tuple(8.0*size for size in range(5))  # asteroid.py

static PyObject *__pyx_pf_14neo_controller_146genexpr(CYTHON_UNUSED PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct__genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct__genexpr *)__pyx_tp_new_14neo_controller___pyx_scope_struct__genexpr(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct__genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct__genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 299, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_14neo_controller_148generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_neo_controller); if (unlikely(!gen)) __PYX_ERR(0, 299, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_14neo_controller_148generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(0, 299, __pyx_L1_error)
  }
  for (__pyx_t_1 = 0; __pyx_t_1 < 5; __pyx_t_1+=1) {
    __pyx_t_2 = PyLong_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_size);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_size, __pyx_t_2);
    __Pyx_GIVEREF(__pyx_t_2);
    __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_8_0, __pyx_cur_scope->__pyx_v_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L6_resume_from_yield:;
    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 299, __pyx_L1_error)
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_14neo_controller_151generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
  __pyx_t_4 = __pyx_pf_14neo_controller_146genexpr(NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROID_RADII_LOOKUP, __pyx_t_2) < 0) __PYX_ERR(0, 299, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct__genexpr {
  PyObject_HEAD
  PyObject *__pyx_v_size;
  Py_ssize_t __pyx_t_0;
};

+0300: ASTEROID_AREA_LOOKUP: Final = tuple(pi*r*r for r in ASTEROID_RADII_LOOKUP)

static PyObject *__pyx_pf_14neo_controller_149genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_1_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_1_genexpr *)__pyx_tp_new_14neo_controller___pyx_scope_struct_1_genexpr(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_1_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_1_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 300, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_14neo_controller_151generator1, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_neo_controller); if (unlikely(!gen)) __PYX_ERR(0, 300, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_14neo_controller_151generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(0, 300, __pyx_L1_error)
  }
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 300, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 300, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 300, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 300, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 300, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_r);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_r, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_cur_scope->__pyx_v_r); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_Multiply(__pyx_t_5, __pyx_cur_scope->__pyx_v_r); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    __Pyx_XGIVEREF(__pyx_t_1);
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
    __pyx_cur_scope->__pyx_t_1 = __pyx_t_2;
    __pyx_cur_scope->__pyx_t_2 = __pyx_t_3;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L6_resume_from_yield:;
    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
    __pyx_cur_scope->__pyx_t_0 = 0;
    __Pyx_XGOTREF(__pyx_t_1);
    __pyx_t_2 = __pyx_cur_scope->__pyx_t_1;
    __pyx_t_3 = __pyx_cur_scope->__pyx_t_2;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 300, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_14neo_controller_154generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ASTEROID_RADII_LOOKUP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 300, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __pyx_pf_14neo_controller_149genexpr(NULL, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 300, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 300, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROID_AREA_LOOKUP, __pyx_t_2) < 0) __PYX_ERR(0, 300, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_1_genexpr {
  PyObject_HEAD
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_r;
  PyObject *__pyx_t_0;
  Py_ssize_t __pyx_t_1;
  PyObject *(*__pyx_t_2)(PyObject *);
};

+0301: ASTEROID_MASS_LOOKUP: Final = tuple(0.25*pi*(8*size)**2 for size in range(5))  # asteroid.py

static PyObject *__pyx_pf_14neo_controller_152genexpr(CYTHON_UNUSED PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_2_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_2_genexpr *)__pyx_tp_new_14neo_controller___pyx_scope_struct_2_genexpr(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_2_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_2_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 301, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_14neo_controller_154generator2, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_neo_controller); if (unlikely(!gen)) __PYX_ERR(0, 301, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_14neo_controller_154generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(0, 301, __pyx_L1_error)
  }
  for (__pyx_t_1 = 0; __pyx_t_1 < 5; __pyx_t_1+=1) {
    __pyx_t_2 = PyLong_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_size);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_size, __pyx_t_2);
    __Pyx_GIVEREF(__pyx_t_2);
    __pyx_t_2 = 0;
    __pyx_t_2 = PyFloat_FromDouble((0.25 * M_PI)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyLong_MultiplyCObj(__pyx_mstate_global->__pyx_int_8, __pyx_cur_scope->__pyx_v_size, 8, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyNumber_Power(__pyx_t_3, __pyx_mstate_global->__pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_r = __pyx_t_3;
    __pyx_t_3 = 0;
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L6_resume_from_yield:;
    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 301, __pyx_L1_error)
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __pyx_pf_14neo_controller_152genexpr(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROID_MASS_LOOKUP, __pyx_t_4) < 0) __PYX_ERR(0, 301, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_2_genexpr {
  PyObject_HEAD
  PyObject *__pyx_v_size;
  Py_ssize_t __pyx_t_0;
};

+0302: RESPAWN_INVINCIBILITY_TIME_S: Final[float] = 3.0  # s

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RESPAWN_INVINCIBILITY_TIME_S, __pyx_mstate_global->__pyx_float_3_0) < 0) __PYX_ERR(0, 302, __pyx_L1_error)

+0303: ASTEROID_COUNT_LOOKUP: Final = (0, 1, 4, 13, 40)  # A size 2 asteroid is 4 asteroids, size 4 is 30, etc. Each asteroid splits into 3, and itself is counted as well. Explicit formula is count(n) = (3^n - 1)/2

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROID_COUNT_LOOKUP, __pyx_mstate_global->__pyx_tuple[88]) < 0) __PYX_ERR(0, 303, __pyx_L1_error)
/* … */
  __pyx_mstate_global->__pyx_tuple[88] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_int_13, __pyx_mstate_global->__pyx_int_40); if (unlikely(!__pyx_mstate_global->__pyx_tuple[88])) __PYX_ERR(0, 303, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[88]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[88]);

+0304: DEGREES_BETWEEN_SHOTS: Final[float] = float(FIRE_COOLDOWN_TS)*SHIP_MAX_TURN_RATE*DELTA_TIME

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_FIRE_COOLDOWN_TS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyNumber_Float(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DEGREES_BETWEEN_SHOTS, __pyx_t_2) < 0) __PYX_ERR(0, 304, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0305: DEGREES_TURNED_PER_TIMESTEP: Final[float] = SHIP_MAX_TURN_RATE*DELTA_TIME

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 305, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 305, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 305, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DEGREES_TURNED_PER_TIMESTEP, __pyx_t_5) < 0) __PYX_ERR(0, 305, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0306: SHIP_RADIUS_PLUS_SIZE_4_ASTEROID_RADIUS: Final[float] = SHIP_RADIUS + ASTEROID_RADII_LOOKUP[4]

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 306, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ASTEROID_RADII_LOOKUP); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 306, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 306, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS_PLUS_SIZE_4_ASTEROID, __pyx_t_4) < 0) __PYX_ERR(0, 306, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 0307: 

 0308: # FIS Settings

+0309: ASTEROIDS_HIT_VERY_GOOD: Final[int] = 65

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_VERY_GOOD, __pyx_mstate_global->__pyx_int_65) < 0) __PYX_ERR(0, 309, __pyx_L1_error)

+0310: ASTEROIDS_HIT_OKAY_CENTER: Final = 23

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_OKAY_CENTER, __pyx_mstate_global->__pyx_int_23) < 0) __PYX_ERR(0, 310, __pyx_L1_error)

 0311: 

 0312: # Dirty globals

 0313: # Store messages and their last printed timestep

+0314: explanation_messages_with_timestamps: dict[str, int] = {}  # Make sure to clear this when timestep is 0 so back-to-back runs work properly!

  __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_explanation_messages_with_timest, __pyx_t_4) < 0) __PYX_ERR(0, 314, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 0315: #total_abs_cruise_speed: float = SHIP_MAX_SPEED/2

 0316: #total_cruise_timesteps: int = round(MAX_CRUISE_TIMESTEPS/2)

 0317: #total_maneuvers_to_learn_from: int = 1

+0318: abs_cruise_speeds: list[float] = [SHIP_MAX_SPEED/2]

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 318, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 318, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyList_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 318, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_abs_cruise_speeds, __pyx_t_4) < 0) __PYX_ERR(0, 318, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0319: cruise_timesteps: list[int] = [round(MAX_CRUISE_TIMESTEPS/2)]

  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_round);
  __pyx_t_5 = __pyx_builtin_round; 
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MAX_CRUISE_TIMESTEPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_10 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 319, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_10};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 319, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_5 = __Pyx_PyList_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 319, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_cruise_timesteps, __pyx_t_5) < 0) __PYX_ERR(0, 319, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0320: overall_fitness_record: list[float] = []

  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_overall_fitness_record, __pyx_t_5) < 0) __PYX_ERR(0, 320, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 0321: #heuristic_fis_iterations = 0

 0322: #heuristic_fis_total_fitness = 0.0

 0323: #random_search_iterations = 0

 0324: #random_search_total_fitness = 0.0

+0325: total_sim_timesteps: int = 0

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_total_sim_timesteps, __pyx_mstate_global->__pyx_int_0) < 0) __PYX_ERR(0, 325, __pyx_L1_error)

 0326: #total_bullet_sim_timesteps = 0

 0327: #total_bullet_sim_iterations = 0

 0328: #update_ts_zero_count = 0

 0329: #update_ts_multiple_count = 0

+0330: unwrap_cache: dict[int, list['Asteroid']] = {} #tuple[float, float, float, float, float]

  __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_unwrap_cache, __pyx_t_5) < 0) __PYX_ERR(0, 330, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 0331: #unwrap_cache_hits: int = 0

 0332: #unwrap_cache_misses: int = 0

 0333: #bullet_sim_time: float = 0.0

 0334: #sim_update_total_time: float = 0.0

 0335: #sim_cull_total_time: float = 0.0

 0336: #unwrap_total_time: float = 0.0

 0337: #asteroids_pending_death_total_cull_time: float = 0.0

 0338: #asteroid_tracking_total_time: float = 0.0

 0339: #asteroid_new_track_total_time: float = 0.0

 0340: 

 0341: 

+0342: cdef class Asteroid:

struct __pyx_obj_14neo_controller_Asteroid {
  PyObject_HEAD
  double pos_x;
  double pos_y;
  double vel_x;
  double vel_y;
  int size;
  double mass;
  double radius;
  int timesteps_until_appearance;
};

+0343:     cdef public double pos_x, pos_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5pos_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5pos_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5pos_x___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_5pos_x___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.pos_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5pos_x_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_5pos_x_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 343, __pyx_L1_error)
  __pyx_v_self->pos_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.pos_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5pos_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5pos_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5pos_y___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_5pos_y___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.pos_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5pos_y_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_5pos_y_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 343, __pyx_L1_error)
  __pyx_v_self->pos_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.pos_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0344:     cdef public double vel_x, vel_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5vel_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5vel_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5vel_x___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_5vel_x___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 344, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.vel_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_5vel_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_5vel_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5vel_x_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_5vel_x_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 344, __pyx_L1_error)
  __pyx_v_self->vel_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.vel_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5vel_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5vel_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5vel_y___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_5vel_y___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 344, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.vel_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_5vel_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_5vel_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_5vel_y_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_5vel_y_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 344, __pyx_L1_error)
  __pyx_v_self->vel_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.vel_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0345:     cdef public int size

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_4size_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_4size___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_4size___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 345, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_4size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_4size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_4size_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_4size_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 345, __pyx_L1_error)
  __pyx_v_self->size = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.size.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0346:     cdef public double mass

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_4mass_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_4mass_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_4mass___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_4mass___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 346, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.mass.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_4mass_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_4mass_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 346, __pyx_L1_error)
  __pyx_v_self->mass = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.mass.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0347:     cdef public double radius

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_6radius_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_6radius_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_6radius___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_6radius___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.radius.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_6radius_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_6radius_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_6radius_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_6radius_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 347, __pyx_L1_error)
  __pyx_v_self->radius = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.radius.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0348:     cdef public int timesteps_until_appearance

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_26timesteps_until_appearance_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_26timesteps_until_appearance_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_26timesteps_until_appearance___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_26timesteps_until_appearance___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->timesteps_until_appearance); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.timesteps_until_appearance.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_26timesteps_until_appearance_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_26timesteps_until_appearance_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_26timesteps_until_appearance_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_26timesteps_until_appearance_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 348, __pyx_L1_error)
  __pyx_v_self->timesteps_until_appearance = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Asteroid.timesteps_until_appearance.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 0349: 

+0350:     def __cinit__(

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_position = 0;
  PyObject *__pyx_v_velocity = 0;
  int __pyx_v_size;
  double __pyx_v_mass;
  double __pyx_v_radius;
  int __pyx_v_timesteps_until_appearance;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_position,&__pyx_mstate_global->__pyx_n_u_velocity,&__pyx_mstate_global->__pyx_n_u_size,&__pyx_mstate_global->__pyx_n_u_mass,&__pyx_mstate_global->__pyx_n_u_radius,&__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance,0};
  PyObject* values[6] = {0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 350, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 350, __pyx_L3_error)
/* … */
  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid___cinit__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_position, PyObject *__pyx_v_velocity, int __pyx_v_size, double __pyx_v_mass, double __pyx_v_radius, int __pyx_v_timesteps_until_appearance) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0351:         self,

+0352:         position=(0.0, 0.0),

      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
/* … */
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
/* … */
  __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_float_0_0, __pyx_mstate_global->__pyx_float_0_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]);

+0353:         velocity=(0.0, 0.0),

      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
    } else {
      switch (__pyx_nargs) {
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
/* … */
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
    }
    __pyx_v_position = values[0];
    __pyx_v_velocity = values[1];
    if (values[2]) {
      __pyx_v_size = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_size == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 354, __pyx_L3_error)
    } else {
      __pyx_v_size = ((int)0);
    }
    if (values[3]) {
      __pyx_v_mass = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_mass == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 355, __pyx_L3_error)
    } else {
      __pyx_v_mass = ((double)0.0);
    }
    if (values[4]) {
      __pyx_v_radius = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 356, __pyx_L3_error)
    } else {
      __pyx_v_radius = ((double)0.0);
    }
    if (values[5]) {
      __pyx_v_timesteps_until_appearance = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_timesteps_until_appearance == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 357, __pyx_L3_error)
    } else {
      __pyx_v_timesteps_until_appearance = ((int)0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 6, __pyx_nargs); __PYX_ERR(0, 350, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Asteroid.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid___cinit__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), __pyx_v_position, __pyx_v_velocity, __pyx_v_size, __pyx_v_mass, __pyx_v_radius, __pyx_v_timesteps_until_appearance);

 0354:         int size=0,

 0355:         double mass=0.0,

 0356:         double radius=0.0,

 0357:         int timesteps_until_appearance=0

 0358:     ):

+0359:         self.pos_x = position[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 359, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_x = __pyx_t_2;

+0360:         self.pos_y = position[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 360, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 360, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_y = __pyx_t_2;

+0361:         self.vel_x = velocity[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_velocity, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_x = __pyx_t_2;

+0362:         self.vel_y = velocity[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_velocity, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 362, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_y = __pyx_t_2;

+0363:         self.size = size

  __pyx_v_self->size = __pyx_v_size;

+0364:         self.mass = mass

  __pyx_v_self->mass = __pyx_v_mass;

+0365:         self.radius = radius

  __pyx_v_self->radius = __pyx_v_radius;

+0366:         self.timesteps_until_appearance = timesteps_until_appearance

  __pyx_v_self->timesteps_until_appearance = __pyx_v_timesteps_until_appearance;

 0367: 

 0368:     property position:

+0369:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_8position_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_8position_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_8position___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_8position___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Asteroid.position.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0370:             return (self.pos_x, self.pos_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 370, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 370, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0371:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_8position_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_8position_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.position.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0372:             self.pos_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 372, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 372, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_x = __pyx_t_2;

+0373:             self.pos_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 373, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_y = __pyx_t_2;

 0374: 

 0375:     property velocity:

+0376:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_8velocity_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_8velocity_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_8velocity___get__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_8velocity___get__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Asteroid.velocity.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0377:             return (self.vel_x, self.vel_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 377, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 377, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 377, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 377, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 377, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0378:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_8Asteroid_8velocity_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_8Asteroid_8velocity_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_8velocity_2__set__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8Asteroid_8velocity_2__set__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.velocity.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0379:             self.vel_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 379, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_x = __pyx_t_2;

+0380:             self.vel_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 380, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_y = __pyx_t_2;

 0381: 

+0382:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_2__str__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_2__str__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Asteroid.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0383:         return ("Asteroid(position=(%f, %f), velocity=(%f, %f), size=%d, mass=%f, radius=%f, timesteps_until_appearance=%d)" %

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_9, 17, 19 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 2 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 13 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 8 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 7 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 9 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8));
  if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 383, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_r = __pyx_t_10;
  __pyx_t_10 = 0;
  goto __pyx_L0;

+0384:                 (self.pos_x, self.pos_y, self.vel_x, self.vel_y, self.size, self.mass, self.radius, self.timesteps_until_appearance))

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyUnicode_From_int(__pyx_v_self->size, 0, ' ', 'd'); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyObject_Format(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_8 = __Pyx_PyObject_Format(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_self->timesteps_until_appearance, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u_Asteroid_position;
  __pyx_t_9[1] = __pyx_t_2;
  __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_9[3] = __pyx_t_3;
  __pyx_t_9[4] = __pyx_mstate_global->__pyx_kp_u_velocity_2;
  __pyx_t_9[5] = __pyx_t_4;
  __pyx_t_9[6] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_9[7] = __pyx_t_5;
  __pyx_t_9[8] = __pyx_mstate_global->__pyx_kp_u_size_2;
  __pyx_t_9[9] = __pyx_t_1;
  __pyx_t_9[10] = __pyx_mstate_global->__pyx_kp_u_mass_2;
  __pyx_t_9[11] = __pyx_t_7;
  __pyx_t_9[12] = __pyx_mstate_global->__pyx_kp_u_radius_2;
  __pyx_t_9[13] = __pyx_t_8;
  __pyx_t_9[14] = __pyx_mstate_global->__pyx_kp_u_timesteps_until_appearance_2;
  __pyx_t_9[15] = __pyx_t_6;
  __pyx_t_9[16] = __pyx_mstate_global->__pyx_kp_u__2;

 0385: 

+0386:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_4__repr__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_4__repr__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Asteroid.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0387:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0388: 

+0389:     def __eq__(self, other):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8Asteroid_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_6__eq__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self), ((PyObject *)__pyx_v_other));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_6__eq__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self, PyObject *__pyx_v_other) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.Asteroid.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0390:         if not isinstance(other, Asteroid):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+0391:             return NotImplemented

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_builtin_NotImplemented);
    __pyx_r = __pyx_builtin_NotImplemented;
    goto __pyx_L0;

+0392:         return (self.pos_x == other.pos_x and

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 392, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_pos_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 392, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 392, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 392, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0393:                 self.pos_y == other.pos_y and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 393, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 393, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 393, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0394:                 self.vel_x == other.vel_x and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_vel_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 394, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 394, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0395:                 self.vel_y == other.vel_y and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_vel_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 395, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 395, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0396:                 self.size == other.size and

  __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 396, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 396, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0397:                 self.mass == other.mass and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 397, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 397, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0398:                 self.radius == other.radius and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 398, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 398, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0399:                 self.timesteps_until_appearance == other.timesteps_until_appearance)

  __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_self->timesteps_until_appearance); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 399, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 399, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 399, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_3 = __pyx_t_4;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_L4_bool_binop_done:;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 0400: 

+0401:     def __hash__(self):

/* Python wrapper */
static Py_hash_t __pyx_pw_14neo_controller_8Asteroid_9__hash__(PyObject *__pyx_v_self); /*proto*/
static Py_hash_t __pyx_pw_14neo_controller_8Asteroid_9__hash__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  Py_hash_t __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_8__hash__(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static Py_hash_t __pyx_pf_14neo_controller_8Asteroid_8__hash__(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  double __pyx_v_combined;
  double __pyx_v_scaled_combined;
  Py_hash_t __pyx_r;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Asteroid.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0402:         cdef double combined = (self.pos_x + 0.4266548291679171 * self.pos_y +

+0403:                                0.8164926348982552 * self.vel_x +

  __pyx_v_combined = (((__pyx_v_self->pos_x + (0.4266548291679171 * __pyx_v_self->pos_y)) + (0.8164926348982552 * __pyx_v_self->vel_x)) + (0.8397584399461026 * __pyx_v_self->vel_y));

 0404:                                0.8397584399461026 * self.vel_y)

+0405:         cdef double scaled_combined = combined * 1_000_000_000

  __pyx_v_scaled_combined = (__pyx_v_combined * 1000000000.0);

+0406:         return int(scaled_combined) + self.size

  __pyx_t_1 = PyLong_FromDouble(__pyx_v_scaled_combined); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 406, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 406, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyLong_AsHash_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (Py_hash_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 406, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  goto __pyx_L0;

 0407: 

+0408:     def float_hash(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_11float_hash(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_8Asteroid_11float_hash = {"float_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_8Asteroid_11float_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_8Asteroid_11float_hash(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("float_hash (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("float_hash", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("float_hash", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_10float_hash(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_10float_hash(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.float_hash", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_8Asteroid_11float_hash, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Asteroid_float_hash, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, __pyx_mstate_global->__pyx_n_u_float_hash, __pyx_t_5) < 0) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0409:         return (self.pos_x + 0.4266548291679171 * self.pos_y +

  __Pyx_XDECREF(__pyx_r);

+0410:                 0.8164926348982552 * self.vel_x +

  __pyx_t_1 = PyFloat_FromDouble((((__pyx_v_self->pos_x + (0.4266548291679171 * __pyx_v_self->pos_y)) + (0.8164926348982552 * __pyx_v_self->vel_x)) + (0.8397584399461026 * __pyx_v_self->vel_y))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0411:                 0.8397584399461026 * self.vel_y)

 0412: 

+0413:     def int_hash(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_13int_hash(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_8Asteroid_13int_hash = {"int_hash", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_8Asteroid_13int_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_8Asteroid_13int_hash(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("int_hash (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("int_hash", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("int_hash", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_12int_hash(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_12int_hash(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Asteroid.int_hash", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_8Asteroid_13int_hash, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Asteroid_int_hash, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 413, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, __pyx_mstate_global->__pyx_n_u_int_hash, __pyx_t_5) < 0) __PYX_ERR(0, 413, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0414:         return int(1_000_000_000 *

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_1 = PyLong_FromDouble((1000000000.0 * (((__pyx_v_self->pos_x + (0.4266548291679171 * __pyx_v_self->pos_y)) + (0.8164926348982552 * __pyx_v_self->vel_x)) + (0.8397584399461026 * __pyx_v_self->vel_y)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0415:             (self.pos_x + 0.4266548291679171 * self.pos_y +

 0416:             0.8164926348982552 * self.vel_x +

 0417:             0.8397584399461026 * self.vel_y)

 0418:         )

 0419: 

+0420:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8Asteroid_15copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_8Asteroid_15copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_8Asteroid_15copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_8Asteroid_15copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_8Asteroid_14copy(((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8Asteroid_14copy(struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.Asteroid.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_8Asteroid_15copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Asteroid_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_5) < 0) __PYX_ERR(0, 420, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+0421:         return Asteroid(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 

+0422:             position=(self.pos_x, self.pos_y),

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 422, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 422, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;

+0423:             velocity=(self.vel_x, self.vel_y),

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 423, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 423, __pyx_L1_error);
  __pyx_t_5 = 0;
  __pyx_t_4 = 0;

+0424:             size=self.size,

  __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 424, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+0425:             mass=self.mass,

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 425, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+0426:             radius=self.radius,

  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 426, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);

+0427:             timesteps_until_appearance=self.timesteps_until_appearance

  __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_self->timesteps_until_appearance); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 427, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_11 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 421, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_6, __pyx_t_11, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 421, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_7, __pyx_t_11, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 421, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_4, __pyx_t_11, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 421, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_5, __pyx_t_11, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 421, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_t_8, __pyx_t_11, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 421, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_t_9, __pyx_t_11, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 421, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_11);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 421, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0428:         )

 0429: 

 0430: '''

 0431: class Asteroid:

 0432:     __slots__ = ('position', 'velocity', 'size', 'mass', 'radius', 'timesteps_until_appearance')

 0433: 

 0434:     def __init__(self, position: tuple[float, float] = (0.0, 0.0), velocity: tuple[float, float] = (0.0, 0.0), size: int = 0, mass: float = 0.0, radius: float = 0.0, timesteps_until_appearance: int = 0) -> None:

 0435:         self.position = position

 0436:         self.velocity = velocity

 0437:         self.size = size

 0438:         self.mass = mass

 0439:         self.radius = radius

 0440:         self.timesteps_until_appearance = timesteps_until_appearance

 0441: 

 0442:     def __str__(self) -> str:

 0443:         return f'Asteroid(position={self.position}, velocity={self.velocity}, size={self.size}, mass={self.mass}, radius={self.radius}, timesteps_until_appearance={self.timesteps_until_appearance})'

 0444: 

 0445:     def __repr__(self) -> str:

 0446:         return self.__str__()

 0447: 

 0448:     def __eq__(self, other: object) -> bool:

 0449:         if not isinstance(other, Asteroid):

 0450:             return NotImplemented

 0451:         return (self.position == other.position and

 0452:                 self.velocity == other.velocity and

 0453:                 self.size == other.size and

 0454:                 self.mass == other.mass and

 0455:                 self.radius == other.radius and

 0456:                 self.timesteps_until_appearance == other.timesteps_until_appearance)

 0457: 

 0458:     def __hash__(self) -> int:

 0459:         # Combine position, velocity, and size into a single float

 0460:         combined: float = self.position[0] + 0.4266548291679171*self.position[1] + 0.8164926348982552*self.velocity[0] + 0.8397584399461026*self.velocity[1]

 0461:         # Scale to reduce the likelihood of collisions after conversion to integer

 0462:         scaled_combined: float = combined * 1_000_000_000

 0463:         # Convert to integer

 0464:         hash_val = int(scaled_combined) + self.size

 0465:         return hash_val

 0466: 

 0467:     def float_hash(self) -> float:

 0468:         # The magic numbers used here were just randomly chosen, to reduce the chance of collisions

 0469:         return self.position[0] + 0.4266548291679171*self.position[1] + 0.8164926348982552*self.velocity[0] + 0.8397584399461026*self.velocity[1]

 0470: 

 0471:     def int_hash(self) -> int:

 0472:         return int(1_000_000_000*(self.position[0] + 0.4266548291679171*self.position[1] + 0.8164926348982552*self.velocity[0] + 0.8397584399461026*self.velocity[1]))

 0473: 

 0474:     def copy(self) -> 'Asteroid':

 0475:         return Asteroid(

 0476:             position=self.position,

 0477:             velocity=self.velocity,

 0478:             size=self.size,

 0479:             mass=self.mass,

 0480:             radius=self.radius,

 0481:             timesteps_until_appearance=self.timesteps_until_appearance

 0482:         )

 0483: '''

 0484: 

+0485: cdef class Ship:

struct __pyx_obj_14neo_controller_Ship {
  PyObject_HEAD
  int is_respawning;
  double pos_x;
  double pos_y;
  double vel_x;
  double vel_y;
  double speed;
  double heading;
  double mass;
  double radius;
  int id;
  PyObject *team;
  int lives_remaining;
  int bullets_remaining;
  int mines_remaining;
  int can_fire;
  double fire_rate;
  int can_deploy_mine;
  double mine_deploy_rate;
  double thrust_min;
  double thrust_max;
  double turn_rate_min;
  double turn_rate_max;
  double max_speed;
  double drag;
};

+0486:     cdef public bint is_respawning

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_13is_respawning_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_13is_respawning_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_13is_respawning___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_13is_respawning___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->is_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 486, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.is_respawning.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_13is_respawning_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_13is_respawning_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_13is_respawning_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_13is_respawning_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L1_error)
  __pyx_v_self->is_respawning = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.is_respawning.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0487:     cdef public double pos_x, pos_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_5pos_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_5pos_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5pos_x___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_5pos_x___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.pos_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5pos_x_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_5pos_x_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 487, __pyx_L1_error)
  __pyx_v_self->pos_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.pos_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_5pos_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_5pos_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5pos_y___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_5pos_y___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.pos_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5pos_y_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_5pos_y_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 487, __pyx_L1_error)
  __pyx_v_self->pos_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.pos_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0488:     cdef public double vel_x, vel_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_5vel_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_5vel_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5vel_x___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_5vel_x___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 488, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.vel_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_5vel_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_5vel_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5vel_x_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_5vel_x_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error)
  __pyx_v_self->vel_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.vel_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_5vel_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_5vel_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5vel_y___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_5vel_y___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 488, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.vel_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_5vel_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_5vel_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5vel_y_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_5vel_y_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error)
  __pyx_v_self->vel_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.vel_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0489:     cdef public double speed

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_5speed_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_5speed_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5speed___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_5speed___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 489, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.speed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_5speed_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_5speed_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_5speed_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_5speed_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L1_error)
  __pyx_v_self->speed = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.speed.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0490:     cdef public double heading

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_7heading_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_7heading_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_7heading___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_7heading___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.heading.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_7heading_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_7heading_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_7heading_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_7heading_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 490, __pyx_L1_error)
  __pyx_v_self->heading = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.heading.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0491:     cdef public double mass

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_4mass_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_4mass_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4mass___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_4mass___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.mass.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4mass_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_4mass_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 491, __pyx_L1_error)
  __pyx_v_self->mass = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.mass.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0492:     cdef public double radius

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_6radius_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_6radius_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_6radius___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_6radius___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 492, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.radius.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_6radius_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_6radius_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_6radius_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_6radius_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error)
  __pyx_v_self->radius = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.radius.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0493:     cdef public int id

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_2id_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_2id_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_2id___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_2id___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 493, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.id.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_2id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_2id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_2id_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_2id_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L1_error)
  __pyx_v_self->id = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.id.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0494:     cdef public object team  # Python str object

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_4team_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_4team_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4team___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_4team___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->team);
  __pyx_r = __pyx_v_self->team;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_4team_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_4team_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4team_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_4team_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_INCREF(__pyx_v_value);
  __Pyx_GIVEREF(__pyx_v_value);
  __Pyx_GOTREF(__pyx_v_self->team);
  __Pyx_DECREF(__pyx_v_self->team);
  __pyx_v_self->team = __pyx_v_value;

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_4team_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_4team_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4team_4__del__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_4team_4__del__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->team);
  __Pyx_DECREF(__pyx_v_self->team);
  __pyx_v_self->team = Py_None;

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0495:     cdef public int lives_remaining

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_15lives_remaining_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_15lives_remaining_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15lives_remaining___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_15lives_remaining___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 495, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.lives_remaining.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_15lives_remaining_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_15lives_remaining_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15lives_remaining_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_15lives_remaining_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 495, __pyx_L1_error)
  __pyx_v_self->lives_remaining = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.lives_remaining.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0496:     cdef public int bullets_remaining

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_17bullets_remaining_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_17bullets_remaining_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_17bullets_remaining___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_17bullets_remaining___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->bullets_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 496, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.bullets_remaining.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_17bullets_remaining_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_17bullets_remaining_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_17bullets_remaining_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_17bullets_remaining_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 496, __pyx_L1_error)
  __pyx_v_self->bullets_remaining = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.bullets_remaining.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0497:     cdef public int mines_remaining

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_15mines_remaining_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_15mines_remaining_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15mines_remaining___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_15mines_remaining___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->mines_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 497, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.mines_remaining.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_15mines_remaining_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_15mines_remaining_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15mines_remaining_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_15mines_remaining_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 497, __pyx_L1_error)
  __pyx_v_self->mines_remaining = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.mines_remaining.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0498:     cdef public bint can_fire

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_8can_fire_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_8can_fire_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_8can_fire___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_8can_fire___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->can_fire); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 498, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.can_fire.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_8can_fire_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_8can_fire_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_8can_fire_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_8can_fire_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 498, __pyx_L1_error)
  __pyx_v_self->can_fire = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.can_fire.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0499:     cdef public double fire_rate

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_9fire_rate_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_9fire_rate_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_9fire_rate___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_9fire_rate___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->fire_rate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.fire_rate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_9fire_rate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_9fire_rate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_9fire_rate_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_9fire_rate_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L1_error)
  __pyx_v_self->fire_rate = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.fire_rate.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0500:     cdef public bint can_deploy_mine

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_15can_deploy_mine_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_15can_deploy_mine_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15can_deploy_mine___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_15can_deploy_mine___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->can_deploy_mine); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 500, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.can_deploy_mine.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_15can_deploy_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_15can_deploy_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15can_deploy_mine_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_15can_deploy_mine_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 500, __pyx_L1_error)
  __pyx_v_self->can_deploy_mine = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.can_deploy_mine.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0501:     cdef public double mine_deploy_rate

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_16mine_deploy_rate_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_16mine_deploy_rate_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_16mine_deploy_rate___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_16mine_deploy_rate___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->mine_deploy_rate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 501, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.mine_deploy_rate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_16mine_deploy_rate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_16mine_deploy_rate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_16mine_deploy_rate_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_16mine_deploy_rate_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error)
  __pyx_v_self->mine_deploy_rate = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.mine_deploy_rate.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0502:     cdef public double thrust_min, thrust_max

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_10thrust_min_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_10thrust_min_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_10thrust_min___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_10thrust_min___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->thrust_min); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 502, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.thrust_min.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_10thrust_min_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_10thrust_min_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_10thrust_min_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_10thrust_min_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 502, __pyx_L1_error)
  __pyx_v_self->thrust_min = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.thrust_min.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_10thrust_max_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_10thrust_max_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_10thrust_max___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_10thrust_max___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->thrust_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 502, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.thrust_max.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_10thrust_max_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_10thrust_max_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_10thrust_max_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_10thrust_max_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 502, __pyx_L1_error)
  __pyx_v_self->thrust_max = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.thrust_max.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0503:     cdef public double turn_rate_min, turn_rate_max

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_13turn_rate_min_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_13turn_rate_min_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_13turn_rate_min___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_13turn_rate_min___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->turn_rate_min); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.turn_rate_min.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_13turn_rate_min_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_13turn_rate_min_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_13turn_rate_min_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_13turn_rate_min_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L1_error)
  __pyx_v_self->turn_rate_min = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.turn_rate_min.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_13turn_rate_max_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_13turn_rate_max_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_13turn_rate_max___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_13turn_rate_max___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->turn_rate_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.turn_rate_max.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_13turn_rate_max_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_13turn_rate_max_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_13turn_rate_max_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_13turn_rate_max_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L1_error)
  __pyx_v_self->turn_rate_max = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.turn_rate_max.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0504:     cdef public double max_speed

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_9max_speed_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_9max_speed_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_9max_speed___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_9max_speed___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->max_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 504, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.max_speed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_9max_speed_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_9max_speed_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_9max_speed_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_9max_speed_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 504, __pyx_L1_error)
  __pyx_v_self->max_speed = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.max_speed.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0505:     cdef public double drag

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_4drag_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_4drag_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4drag___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_4drag___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->drag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 505, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.drag.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_4drag_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_4drag_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4drag_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_4drag_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 505, __pyx_L1_error)
  __pyx_v_self->drag = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Ship.drag.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 0506: 

+0507:     def __cinit__(self,

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_is_respawning = 0;
  PyObject *__pyx_v_position = 0;
  PyObject *__pyx_v_velocity = 0;
  double __pyx_v_speed;
  double __pyx_v_heading;
  double __pyx_v_mass;
  double __pyx_v_radius;
  int __pyx_v_id;
  PyObject *__pyx_v_team = 0;
  int __pyx_v_lives_remaining;
  int __pyx_v_bullets_remaining;
  int __pyx_v_mines_remaining;
  PyObject *__pyx_v_can_fire = 0;
  double __pyx_v_fire_rate;
  PyObject *__pyx_v_can_deploy_mine = 0;
  double __pyx_v_mine_deploy_rate;
  PyObject *__pyx_v_thrust_range = 0;
  PyObject *__pyx_v_turn_rate_range = 0;
  double __pyx_v_max_speed;
  double __pyx_v_drag;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_is_respawning,&__pyx_mstate_global->__pyx_n_u_position,&__pyx_mstate_global->__pyx_n_u_velocity,&__pyx_mstate_global->__pyx_n_u_speed,&__pyx_mstate_global->__pyx_n_u_heading,&__pyx_mstate_global->__pyx_n_u_mass,&__pyx_mstate_global->__pyx_n_u_radius,&__pyx_mstate_global->__pyx_n_u_id,&__pyx_mstate_global->__pyx_n_u_team,&__pyx_mstate_global->__pyx_n_u_lives_remaining,&__pyx_mstate_global->__pyx_n_u_bullets_remaining,&__pyx_mstate_global->__pyx_n_u_mines_remaining,&__pyx_mstate_global->__pyx_n_u_can_fire,&__pyx_mstate_global->__pyx_n_u_fire_rate,&__pyx_mstate_global->__pyx_n_u_can_deploy_mine,&__pyx_mstate_global->__pyx_n_u_mine_deploy_rate,&__pyx_mstate_global->__pyx_n_u_thrust_range,&__pyx_mstate_global->__pyx_n_u_turn_rate_range,&__pyx_mstate_global->__pyx_n_u_max_speed,&__pyx_mstate_global->__pyx_n_u_drag,0};
  PyObject* values[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 507, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case 20:
        values[19] = __Pyx_ArgRef_VARARGS(__pyx_args, 19);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 19:
        values[18] = __Pyx_ArgRef_VARARGS(__pyx_args, 18);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 18:
        values[17] = __Pyx_ArgRef_VARARGS(__pyx_args, 17);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 17:
        values[16] = __Pyx_ArgRef_VARARGS(__pyx_args, 16);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 16:
        values[15] = __Pyx_ArgRef_VARARGS(__pyx_args, 15);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 15:
        values[14] = __Pyx_ArgRef_VARARGS(__pyx_args, 14);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 14:
        values[13] = __Pyx_ArgRef_VARARGS(__pyx_args, 13);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 13:
        values[12] = __Pyx_ArgRef_VARARGS(__pyx_args, 12);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 12:
        values[11] = __Pyx_ArgRef_VARARGS(__pyx_args, 11);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 11:
        values[10] = __Pyx_ArgRef_VARARGS(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_VARARGS(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_VARARGS(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_VARARGS(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 507, __pyx_L3_error)
/* … */
  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship___cinit__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_is_respawning, PyObject *__pyx_v_position, PyObject *__pyx_v_velocity, double __pyx_v_speed, double __pyx_v_heading, double __pyx_v_mass, double __pyx_v_radius, int __pyx_v_id, PyObject *__pyx_v_team, int __pyx_v_lives_remaining, int __pyx_v_bullets_remaining, int __pyx_v_mines_remaining, PyObject *__pyx_v_can_fire, double __pyx_v_fire_rate, PyObject *__pyx_v_can_deploy_mine, double __pyx_v_mine_deploy_rate, PyObject *__pyx_v_thrust_range, PyObject *__pyx_v_turn_rate_range, double __pyx_v_max_speed, double __pyx_v_drag) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Ship.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0508:                   is_respawning = False,

      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));
/* … */
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)Py_False));

+0509:                   position = (0.0, 0.0),

      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
/* … */
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));

+0510:                   velocity = (0.0, 0.0),

      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
      if (!values[8]) values[8] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_kp_u__3));
/* … */
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
      if (!values[8]) values[8] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_kp_u__3));

 0511:                   double speed=0.0,

 0512:                   double heading=0.0,

 0513:                   double mass=0.0,

 0514:                   double radius=0.0,

 0515:                   int id=0,

 0516:                   team='',

 0517:                   int lives_remaining=0,

 0518:                   int bullets_remaining=0,

 0519:                   int mines_remaining=0,

+0520:                   can_fire=True,

      if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)Py_True));
/* … */
      if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)Py_True));

 0521:                   double fire_rate=0.0,

+0522:                   can_deploy_mine=True,

      if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_True));
      if (!values[16]) values[16] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__4);
      if (!values[17]) values[17] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__5);
    } else {
      switch (__pyx_nargs) {
        case 20:
        values[19] = __Pyx_ArgRef_VARARGS(__pyx_args, 19);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 19:
        values[18] = __Pyx_ArgRef_VARARGS(__pyx_args, 18);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 18:
        values[17] = __Pyx_ArgRef_VARARGS(__pyx_args, 17);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 17:
        values[16] = __Pyx_ArgRef_VARARGS(__pyx_args, 16);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 16:
        values[15] = __Pyx_ArgRef_VARARGS(__pyx_args, 15);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 15:
        values[14] = __Pyx_ArgRef_VARARGS(__pyx_args, 14);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 14:
        values[13] = __Pyx_ArgRef_VARARGS(__pyx_args, 13);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 13:
        values[12] = __Pyx_ArgRef_VARARGS(__pyx_args, 12);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 12:
        values[11] = __Pyx_ArgRef_VARARGS(__pyx_args, 11);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 11:
        values[10] = __Pyx_ArgRef_VARARGS(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_VARARGS(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_VARARGS(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_VARARGS(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
/* … */
      if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_True));
      if (!values[16]) values[16] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__4);
      if (!values[17]) values[17] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__5);
    }
    __pyx_v_is_respawning = values[0];
    __pyx_v_position = values[1];
    __pyx_v_velocity = values[2];
    if (values[3]) {
      __pyx_v_speed = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L3_error)
    } else {
      __pyx_v_speed = ((double)0.0);
    }
    if (values[4]) {
      __pyx_v_heading = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_heading == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L3_error)
    } else {
      __pyx_v_heading = ((double)0.0);
    }
    if (values[5]) {
      __pyx_v_mass = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_mass == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 513, __pyx_L3_error)
    } else {
      __pyx_v_mass = ((double)0.0);
    }
    if (values[6]) {
      __pyx_v_radius = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L3_error)
    } else {
      __pyx_v_radius = ((double)0.0);
    }
    if (values[7]) {
      __pyx_v_id = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 515, __pyx_L3_error)
    } else {
      __pyx_v_id = ((int)0);
    }
    __pyx_v_team = values[8];
    if (values[9]) {
      __pyx_v_lives_remaining = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_lives_remaining == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L3_error)
    } else {
      __pyx_v_lives_remaining = ((int)0);
    }
    if (values[10]) {
      __pyx_v_bullets_remaining = __Pyx_PyLong_As_int(values[10]); if (unlikely((__pyx_v_bullets_remaining == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L3_error)
    } else {
      __pyx_v_bullets_remaining = ((int)0);
    }
    if (values[11]) {
      __pyx_v_mines_remaining = __Pyx_PyLong_As_int(values[11]); if (unlikely((__pyx_v_mines_remaining == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L3_error)
    } else {
      __pyx_v_mines_remaining = ((int)0);
    }
    __pyx_v_can_fire = values[12];
    if (values[13]) {
      __pyx_v_fire_rate = __Pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_fire_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 521, __pyx_L3_error)
    } else {
      __pyx_v_fire_rate = ((double)0.0);
    }
    __pyx_v_can_deploy_mine = values[14];
    if (values[15]) {
      __pyx_v_mine_deploy_rate = __Pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_mine_deploy_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L3_error)
    } else {
      __pyx_v_mine_deploy_rate = ((double)0.0);
    }
    __pyx_v_thrust_range = values[16];
    __pyx_v_turn_rate_range = values[17];
    if (values[18]) {
      __pyx_v_max_speed = __Pyx_PyFloat_AsDouble(values[18]); if (unlikely((__pyx_v_max_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L3_error)
    } else {
      __pyx_v_max_speed = __pyx_mstate_global->__pyx_k__6;
    }
    if (values[19]) {
      __pyx_v_drag = __Pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_drag == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L3_error)
    } else {
      __pyx_v_drag = __pyx_mstate_global->__pyx_k__7;
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 20, __pyx_nargs); __PYX_ERR(0, 507, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Ship.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_4Ship___cinit__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), __pyx_v_is_respawning, __pyx_v_position, __pyx_v_velocity, __pyx_v_speed, __pyx_v_heading, __pyx_v_mass, __pyx_v_radius, __pyx_v_id, __pyx_v_team, __pyx_v_lives_remaining, __pyx_v_bullets_remaining, __pyx_v_mines_remaining, __pyx_v_can_fire, __pyx_v_fire_rate, __pyx_v_can_deploy_mine, __pyx_v_mine_deploy_rate, __pyx_v_thrust_range, __pyx_v_turn_rate_range, __pyx_v_max_speed, __pyx_v_drag);

 0523:                   double mine_deploy_rate=0.0,

+0524:                   thrust_range=(-SHIP_MAX_THRUST, SHIP_MAX_THRUST),

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 524, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Negative(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 524, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 524, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_10 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 524, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_mstate_global->__pyx_k__4 = __pyx_t_10;
  __Pyx_GIVEREF(__pyx_t_10);
  __pyx_t_10 = 0;

+0525:                   turn_rate_range=(-SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE),

  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 525, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_5 = PyNumber_Negative(__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 525, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 525, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_4 = PyTuple_Pack(2, __pyx_t_5, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 525, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_mstate_global->__pyx_k__5 = __pyx_t_4;
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_t_4 = 0;

+0526:                   double max_speed=SHIP_MAX_SPEED,

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 526, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_mstate_global->__pyx_k__6 = __pyx_t_7;

+0527:                   double drag=SHIP_DRAG):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 527, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_mstate_global->__pyx_k__7 = __pyx_t_7;

+0528:         self.is_respawning = is_respawning

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_is_respawning); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error)
  __pyx_v_self->is_respawning = __pyx_t_1;

+0529:         self.pos_x = position[0]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 529, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 529, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->pos_x = __pyx_t_3;

+0530:         self.pos_y = position[1]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 530, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 530, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->pos_y = __pyx_t_3;

+0531:         self.vel_x = velocity[0]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_velocity, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 531, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->vel_x = __pyx_t_3;

+0532:         self.vel_y = velocity[1]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_velocity, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 532, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 532, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->vel_y = __pyx_t_3;

+0533:         self.speed = speed

  __pyx_v_self->speed = __pyx_v_speed;

+0534:         self.heading = heading

  __pyx_v_self->heading = __pyx_v_heading;

+0535:         self.mass = mass

  __pyx_v_self->mass = __pyx_v_mass;

+0536:         self.radius = radius

  __pyx_v_self->radius = __pyx_v_radius;

+0537:         self.id = id

  __pyx_v_self->id = __pyx_v_id;

+0538:         self.team = team

  __Pyx_INCREF(__pyx_v_team);
  __Pyx_GIVEREF(__pyx_v_team);
  __Pyx_GOTREF(__pyx_v_self->team);
  __Pyx_DECREF(__pyx_v_self->team);
  __pyx_v_self->team = __pyx_v_team;

+0539:         self.lives_remaining = lives_remaining

  __pyx_v_self->lives_remaining = __pyx_v_lives_remaining;

+0540:         self.bullets_remaining = bullets_remaining

  __pyx_v_self->bullets_remaining = __pyx_v_bullets_remaining;

+0541:         self.mines_remaining = mines_remaining

  __pyx_v_self->mines_remaining = __pyx_v_mines_remaining;

+0542:         self.can_fire = can_fire

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_can_fire); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 542, __pyx_L1_error)
  __pyx_v_self->can_fire = __pyx_t_1;

+0543:         self.fire_rate = fire_rate

  __pyx_v_self->fire_rate = __pyx_v_fire_rate;

+0544:         self.can_deploy_mine = can_deploy_mine

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_can_deploy_mine); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 544, __pyx_L1_error)
  __pyx_v_self->can_deploy_mine = __pyx_t_1;

+0545:         self.mine_deploy_rate = mine_deploy_rate

  __pyx_v_self->mine_deploy_rate = __pyx_v_mine_deploy_rate;

+0546:         self.thrust_min = thrust_range[0]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_thrust_range, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 546, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 546, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->thrust_min = __pyx_t_3;

+0547:         self.thrust_max = thrust_range[1]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_thrust_range, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 547, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->thrust_max = __pyx_t_3;

+0548:         self.turn_rate_min = turn_rate_range[0]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_turn_rate_range, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 548, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->turn_rate_min = __pyx_t_3;

+0549:         self.turn_rate_max = turn_rate_range[1]

  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_turn_rate_range, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 549, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 549, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->turn_rate_max = __pyx_t_3;

+0550:         self.max_speed = max_speed

  __pyx_v_self->max_speed = __pyx_v_max_speed;

+0551:         self.drag = drag

  __pyx_v_self->drag = __pyx_v_drag;

 0552: 

 0553:     property position:

+0554:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_8position_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_8position_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_8position___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_8position___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Ship.position.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0555:             return (self.pos_x, self.pos_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 555, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 555, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 555, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 555, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0556:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_8position_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_8position_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.position.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0557:             self.pos_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 557, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_x = __pyx_t_2;

+0558:             self.pos_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 558, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 558, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_y = __pyx_t_2;

 0559: 

 0560:     property velocity:

+0561:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_8velocity_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_8velocity_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_8velocity___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_8velocity___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Ship.velocity.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0562:             return (self.vel_x, self.vel_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 562, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 562, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 562, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 562, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 562, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0563:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_8velocity_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_8velocity_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_8velocity_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_8velocity_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.velocity.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0564:             self.vel_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 564, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 564, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_x = __pyx_t_2;

+0565:             self.vel_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 565, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_y = __pyx_t_2;

 0566: 

 0567:     property thrust_range:

+0568:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_12thrust_range_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_12thrust_range_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_12thrust_range___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_12thrust_range___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Ship.thrust_range.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0569:             return (self.thrust_min, self.thrust_max)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->thrust_min); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 569, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->thrust_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 569, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 569, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 569, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 569, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0570:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_12thrust_range_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_12thrust_range_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_12thrust_range_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_12thrust_range_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.thrust_range.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0571:             self.thrust_min = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 571, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 571, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->thrust_min = __pyx_t_2;

+0572:             self.thrust_max = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 572, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->thrust_max = __pyx_t_2;

 0573: 

 0574:     property turn_rate_range:

+0575:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_15turn_rate_range_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_15turn_rate_range_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15turn_rate_range___get__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_15turn_rate_range___get__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Ship.turn_rate_range.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0576:             return (self.turn_rate_min, self.turn_rate_max)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->turn_rate_min); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->turn_rate_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 576, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 576, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0577:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Ship_15turn_rate_range_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_4Ship_15turn_rate_range_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_15turn_rate_range_2__set__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Ship_15turn_rate_range_2__set__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Ship.turn_rate_range.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0578:             self.turn_rate_min = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 578, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 578, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->turn_rate_min = __pyx_t_2;

+0579:             self.turn_rate_max = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 579, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 579, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->turn_rate_max = __pyx_t_2;

 0580: 

+0581:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_2__str__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_2__str__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_24);
  __Pyx_XDECREF(__pyx_t_25);
  __Pyx_AddTraceback("neo_controller.Ship.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0582:         return ('Ship(is_respawning=%s, position=(%f, %f), velocity=(%f, %f), speed=%f, heading=%f, mass=%f, radius=%f, id=%d, team="%s", lives_remaining=%d, bullets_remaining=%d, mines_remaining=%d, can_fire=%s, fire_rate=%f, can_deploy_mine=%s, mine_deploy_rate=%f, thrust_range=(%f, %f), turn_rate_range=(%f, %f), max_speed=%f, drag=%f)'

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_18 = __Pyx_PyUnicode_Join(__pyx_t_26, 49, 19 * 3 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 12 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 2 * 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 13 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 9 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 7 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 8 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_11) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_12) + 20 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13) + 18 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14) + 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19) + 16 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_20) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_21) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_22) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_23) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_24) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_11) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_17) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_19) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_20) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_21) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_22) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_23) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_24) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25));
  PyMem_Free(__pyx_t_26);
  if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 582, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
  __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
  __pyx_r = __pyx_t_18;
  __pyx_t_18 = 0;
  goto __pyx_L0;

+0583:                 % (self.is_respawning, self.pos_x, self.pos_y, self.vel_x, self.vel_y, self.speed, self.heading, self.mass, self.radius, self.id, self.team, self.lives_remaining, self.bullets_remaining, self.mines_remaining, self.can_fire, self.fire_rate, self.can_deploy_mine, self.mine_deploy_rate, self.thrust_min, self.thrust_max, self.turn_rate_min, self.turn_rate_max, self.max_speed, self.drag))

  __pyx_t_1 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->is_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->speed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_8 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_9 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_10 = __Pyx_PyObject_Format(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_self->id, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_11 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->team), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_12 = __Pyx_PyUnicode_From_int(__pyx_v_self->lives_remaining, 0, ' ', 'd'); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyUnicode_From_int(__pyx_v_self->bullets_remaining, 0, ' ', 'd'); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_14 = __Pyx_PyUnicode_From_int(__pyx_v_self->mines_remaining, 0, ' ', 'd'); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_15 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->can_fire); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_16 = PyFloat_FromDouble(__pyx_v_self->fire_rate); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_17 = __Pyx_PyObject_Format(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  __pyx_t_16 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->can_deploy_mine); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->mine_deploy_rate); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_19 = __Pyx_PyObject_Format(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_19);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->thrust_min); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_20 = __Pyx_PyObject_Format(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->thrust_max); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_21 = __Pyx_PyObject_Format(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->turn_rate_min); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_22 = __Pyx_PyObject_Format(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->turn_rate_max); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_23 = __Pyx_PyObject_Format(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->max_speed); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_24 = __Pyx_PyObject_Format(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_24);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->drag); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_25 = __Pyx_PyObject_Format(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_26 = (PyObject **) PyMem_Calloc(49, sizeof(PyObject*));
  if (unlikely(!__pyx_t_26)) {
    PyErr_NoMemory(); __PYX_ERR(0, 582, __pyx_L1_error)
  }
  __pyx_t_26[0] = __pyx_mstate_global->__pyx_kp_u_Ship_is_respawning;
  __pyx_t_26[1] = __pyx_t_1;
  __pyx_t_26[2] = __pyx_mstate_global->__pyx_kp_u_position_2;
  __pyx_t_26[3] = __pyx_t_3;
  __pyx_t_26[4] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_26[5] = __pyx_t_4;
  __pyx_t_26[6] = __pyx_mstate_global->__pyx_kp_u_velocity_2;
  __pyx_t_26[7] = __pyx_t_5;
  __pyx_t_26[8] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_26[9] = __pyx_t_6;
  __pyx_t_26[10] = __pyx_mstate_global->__pyx_kp_u_speed_2;
  __pyx_t_26[11] = __pyx_t_7;
  __pyx_t_26[12] = __pyx_mstate_global->__pyx_kp_u_heading_2;
  __pyx_t_26[13] = __pyx_t_8;
  __pyx_t_26[14] = __pyx_mstate_global->__pyx_kp_u_mass_2;
  __pyx_t_26[15] = __pyx_t_9;
  __pyx_t_26[16] = __pyx_mstate_global->__pyx_kp_u_radius_2;
  __pyx_t_26[17] = __pyx_t_10;
  __pyx_t_26[18] = __pyx_mstate_global->__pyx_kp_u_id_2;
  __pyx_t_26[19] = __pyx_t_2;
  __pyx_t_26[20] = __pyx_mstate_global->__pyx_kp_u_team_2;
  __pyx_t_26[21] = __pyx_t_11;
  __pyx_t_26[22] = __pyx_mstate_global->__pyx_kp_u_lives_remaining_2;
  __pyx_t_26[23] = __pyx_t_12;
  __pyx_t_26[24] = __pyx_mstate_global->__pyx_kp_u_bullets_remaining_2;
  __pyx_t_26[25] = __pyx_t_13;
  __pyx_t_26[26] = __pyx_mstate_global->__pyx_kp_u_mines_remaining_2;
  __pyx_t_26[27] = __pyx_t_14;
  __pyx_t_26[28] = __pyx_mstate_global->__pyx_kp_u_can_fire_2;
  __pyx_t_26[29] = __pyx_t_15;
  __pyx_t_26[30] = __pyx_mstate_global->__pyx_kp_u_fire_rate_2;
  __pyx_t_26[31] = __pyx_t_17;
  __pyx_t_26[32] = __pyx_mstate_global->__pyx_kp_u_can_deploy_mine_2;
  __pyx_t_26[33] = __pyx_t_16;
  __pyx_t_26[34] = __pyx_mstate_global->__pyx_kp_u_mine_deploy_rate_2;
  __pyx_t_26[35] = __pyx_t_19;
  __pyx_t_26[36] = __pyx_mstate_global->__pyx_kp_u_thrust_range_2;
  __pyx_t_26[37] = __pyx_t_20;
  __pyx_t_26[38] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_26[39] = __pyx_t_21;
  __pyx_t_26[40] = __pyx_mstate_global->__pyx_kp_u_turn_rate_range_2;
  __pyx_t_26[41] = __pyx_t_22;
  __pyx_t_26[42] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_26[43] = __pyx_t_23;
  __pyx_t_26[44] = __pyx_mstate_global->__pyx_kp_u_max_speed_2;
  __pyx_t_26[45] = __pyx_t_24;
  __pyx_t_26[46] = __pyx_mstate_global->__pyx_kp_u_drag_2;
  __pyx_t_26[47] = __pyx_t_25;
  __pyx_t_26[48] = __pyx_mstate_global->__pyx_kp_u__2;

 0584: 

+0585:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_4__repr__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_4__repr__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Ship.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0586:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0587: 

+0588:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_4Ship_7copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_4Ship_7copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_4Ship_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_4Ship_6copy(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_6copy(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_24);
  __Pyx_AddTraceback("neo_controller.Ship.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_4Ship_7copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Ship_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[49])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 588, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < 0) __PYX_ERR(0, 588, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0589:         return Ship(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship); 

+0590:             is_respawning = self.is_respawning,

  __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->is_respawning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 590, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+0591:             position = (self.pos_x, self.pos_y),

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 591, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 591, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 591, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 591, __pyx_L1_error);
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;

+0592:             velocity = (self.vel_x, self.vel_y),

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 592, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 592, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 592, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 592, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 592, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_5 = 0;

+0593:             speed = self.speed,

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 593, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+0594:             heading = self.heading,

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 594, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);

+0595:             mass = self.mass,

  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 595, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);

+0596:             radius = self.radius,

  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);

+0597:             id = self.id,

  __pyx_t_11 = __Pyx_PyLong_From_int(__pyx_v_self->id); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 597, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);

 0598:             team = self.team,

+0599:             lives_remaining = self.lives_remaining,

  __pyx_t_12 = __Pyx_PyLong_From_int(__pyx_v_self->lives_remaining); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 599, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);

+0600:             bullets_remaining = self.bullets_remaining,

  __pyx_t_13 = __Pyx_PyLong_From_int(__pyx_v_self->bullets_remaining); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);

+0601:             mines_remaining = self.mines_remaining,

  __pyx_t_14 = __Pyx_PyLong_From_int(__pyx_v_self->mines_remaining); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);

+0602:             can_fire = self.can_fire,

  __pyx_t_15 = __Pyx_PyBool_FromLong(__pyx_v_self->can_fire); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 602, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);

+0603:             fire_rate = self.fire_rate,

  __pyx_t_16 = PyFloat_FromDouble(__pyx_v_self->fire_rate); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);

+0604:             can_deploy_mine = self.can_deploy_mine,

  __pyx_t_17 = __Pyx_PyBool_FromLong(__pyx_v_self->can_deploy_mine); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 604, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);

+0605:             mine_deploy_rate = self.mine_deploy_rate,

  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_self->mine_deploy_rate); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 605, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);

+0606:             thrust_range = (self.thrust_min, self.thrust_max),

  __pyx_t_19 = PyFloat_FromDouble(__pyx_v_self->thrust_min); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 606, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_19);
  __pyx_t_20 = PyFloat_FromDouble(__pyx_v_self->thrust_max); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 606, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __pyx_t_21 = PyTuple_New(2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 606, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __Pyx_GIVEREF(__pyx_t_19);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_19) != (0)) __PYX_ERR(0, 606, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_20);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 1, __pyx_t_20) != (0)) __PYX_ERR(0, 606, __pyx_L1_error);
  __pyx_t_19 = 0;
  __pyx_t_20 = 0;

+0607:             turn_rate_range = (self.turn_rate_min, self.turn_rate_max),

  __pyx_t_20 = PyFloat_FromDouble(__pyx_v_self->turn_rate_min); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __pyx_t_19 = PyFloat_FromDouble(__pyx_v_self->turn_rate_max); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_19);
  __pyx_t_22 = PyTuple_New(2); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_GIVEREF(__pyx_t_20);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_20) != (0)) __PYX_ERR(0, 607, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_19);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_22, 1, __pyx_t_19) != (0)) __PYX_ERR(0, 607, __pyx_L1_error);
  __pyx_t_20 = 0;
  __pyx_t_19 = 0;

+0608:             max_speed = self.max_speed,

  __pyx_t_19 = PyFloat_FromDouble(__pyx_v_self->max_speed); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_19);

+0609:             drag = self.drag

  __pyx_t_20 = PyFloat_FromDouble(__pyx_v_self->drag); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 609, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __pyx_t_23 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 20 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_24 = __Pyx_MakeVectorcallBuilderKwds(20); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 589, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_24);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_is_respawning, __pyx_t_4, __pyx_t_24, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_7, __pyx_t_24, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_8, __pyx_t_24, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_speed, __pyx_t_5, __pyx_t_24, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_heading, __pyx_t_6, __pyx_t_24, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_9, __pyx_t_24, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_t_10, __pyx_t_24, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_id, __pyx_t_11, __pyx_t_24, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_team, __pyx_v_self->team, __pyx_t_24, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_lives_remaining, __pyx_t_12, __pyx_t_24, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_bullets_remaining, __pyx_t_13, __pyx_t_24, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mines_remaining, __pyx_t_14, __pyx_t_24, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_can_fire, __pyx_t_15, __pyx_t_24, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_rate, __pyx_t_16, __pyx_t_24, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_can_deploy_mine, __pyx_t_17, __pyx_t_24, __pyx_callargs+1, 14) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mine_deploy_rate, __pyx_t_18, __pyx_t_24, __pyx_callargs+1, 15) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust_range, __pyx_t_21, __pyx_t_24, __pyx_callargs+1, 16) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate_range, __pyx_t_22, __pyx_t_24, __pyx_callargs+1, 17) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_max_speed, __pyx_t_19, __pyx_t_24, __pyx_callargs+1, 18) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_drag, __pyx_t_20, __pyx_t_24, __pyx_callargs+1, 19) < 0) __PYX_ERR(0, 589, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_23, (1-__pyx_t_23) | (__pyx_t_23*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_24);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 589, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0610:         )

 0611: 

+0612:     def __eq__(self, other):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Ship_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Ship_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Ship_8__eq__(((struct __pyx_obj_14neo_controller_Ship *)__pyx_v_self), ((PyObject *)__pyx_v_other));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Ship_8__eq__(struct __pyx_obj_14neo_controller_Ship *__pyx_v_self, PyObject *__pyx_v_other) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.Ship.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0613:         if not isinstance(other, Ship):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship); 
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+0614:             return NotImplemented

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_builtin_NotImplemented);
    __pyx_r = __pyx_builtin_NotImplemented;
    goto __pyx_L0;

+0615:         return (self.is_respawning == other.is_respawning and

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->is_respawning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 615, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 615, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 615, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 615, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0616:                 (self.pos_x, self.pos_y) == other.position and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 616, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 616, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 616, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 616, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0617:                 (self.vel_x, self.vel_y) == other.velocity and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 617, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 617, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 617, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 617, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 617, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 617, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 617, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 617, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0618:                 self.speed == other.speed and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->speed); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 618, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 618, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 618, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 618, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0619:                 self.heading == other.heading and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 619, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 619, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 619, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 619, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0620:                 self.mass == other.mass and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 620, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 620, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 620, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 620, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0621:                 self.radius == other.radius and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->radius); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 621, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 621, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0622:                 self.id == other.id and

  __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_self->id); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 622, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_id); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 622, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 622, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 622, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0623:                 self.team == other.team and

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_team); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 623, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyObject_RichCompare(__pyx_v_self->team, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 623, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 623, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0624:                 self.lives_remaining == other.lives_remaining and

  __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_self->lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 624, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 624, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0625:                 self.bullets_remaining == other.bullets_remaining and

  __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_self->bullets_remaining); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 625, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 625, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 625, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 625, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0626:                 self.mines_remaining == other.mines_remaining and

  __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_self->mines_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 626, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 626, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 626, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 626, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

 0627:                 # self.can_fire == other.can_fire and

+0628:                 self.fire_rate == other.fire_rate and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->fire_rate); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_fire_rate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 628, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 628, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_bool_binop_done;
  }

 0629:                 # self.can_deploy_mine == other.can_deploy_mine and

+0630:                 self.mine_deploy_rate == other.mine_deploy_rate and

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->mine_deploy_rate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 630, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mine_deploy_rate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 630, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 630, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 630, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0631:                 (self.thrust_min, self.thrust_max) == other.thrust_range and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->thrust_min); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->thrust_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 631, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 631, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_thrust_range); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 631, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 631, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0632:                 (self.turn_rate_min, self.turn_rate_max) == other.turn_rate_range and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->turn_rate_min); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->turn_rate_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 632, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 632, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_turn_rate_range); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 632, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 632, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0633:                 self.max_speed == other.max_speed and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->max_speed); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 633, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_max_speed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 633, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 633, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 633, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0634:                 self.drag == other.drag)

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->drag); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_drag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 634, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_3 = __pyx_t_6;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_L4_bool_binop_done:;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 0635: 

 0636: '''

 0637: class Ship:

 0638:     __slots__ = ('is_respawning', 'position', 'velocity', 'speed', 'heading', 'mass', 'radius', 'id', 'team', 'lives_remaining', 'bullets_remaining', 'mines_remaining', 'can_fire', 'fire_rate', 'can_deploy_mine', 'mine_deploy_rate', 'thrust_range', 'turn_rate_range', 'max_speed', 'drag')

 0639: 

 0640:     def __init__(self, is_respawning: bool = False, position: tuple[float, float] = (0.0, 0.0), velocity: tuple[float, float] = (0.0, 0.0), speed: float = 0.0, heading: float = 0.0, mass: float = 0.0, radius: float = 0.0, id: int = 0, team: str = '', lives_remaining: int = 0, bullets_remaining: int = 0, mines_remaining: int = 0, can_fire: bool = True, fire_rate: float = 0.0, can_deploy_mine: bool = True, mine_deploy_rate: float = 0.0, thrust_range: tuple[float, float] = (-SHIP_MAX_THRUST, SHIP_MAX_THRUST), turn_rate_range: tuple[float, float] = (-SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE), max_speed: float = SHIP_MAX_SPEED, drag: float = SHIP_DRAG) -> None:

 0641:         self.is_respawning = is_respawning

 0642:         self.position = position

 0643:         self.velocity = velocity

 0644:         self.speed = speed

 0645:         self.heading = heading

 0646:         self.mass = mass

 0647:         self.radius = radius

 0648:         self.id = id

 0649:         self.team = team

 0650:         self.lives_remaining = lives_remaining

 0651:         self.bullets_remaining = bullets_remaining

 0652:         self.mines_remaining = mines_remaining

 0653:         self.can_fire = can_fire

 0654:         self.fire_rate = fire_rate

 0655:         self.can_deploy_mine = can_deploy_mine

 0656:         self.mine_deploy_rate = mine_deploy_rate

 0657:         self.thrust_range = thrust_range

 0658:         self.turn_rate_range = turn_rate_range

 0659:         self.max_speed = max_speed

 0660:         self.drag = drag

 0661: 

 0662:     def __str__(self) -> str:

 0663:         return f'Ship(is_respawning={self.is_respawning}, position={self.position}, velocity={self.velocity}, speed={self.speed}, heading={self.heading}, mass={self.mass}, radius={self.radius}, id={self.id}, team="{self.team}", lives_remaining={self.lives_remaining}, bullets_remaining={self.bullets_remaining}, mines_remaining={self.mines_remaining}, can_fire={self.can_fire}, fire_rate={self.fire_rate}, can_deploy_mine={self.can_deploy_mine}, mine_deploy_rate={self.mine_deploy_rate}, thrust_range={self.thrust_range}, turn_rate_range={self.turn_rate_range}, max_speed={self.max_speed}, drag={self.drag})'

 0664: 

 0665:     def __repr__(self) -> str:

 0666:         return self.__str__()

 0667: 

 0668:     def copy(self) -> 'Ship':

 0669:         return Ship(

 0670:             is_respawning=self.is_respawning,

 0671:             position=self.position,

 0672:             velocity=self.velocity,

 0673:             speed=self.speed,

 0674:             heading=self.heading,

 0675:             mass=self.mass,

 0676:             radius=self.radius,

 0677:             id=self.id,

 0678:             team=self.team,

 0679:             lives_remaining=self.lives_remaining,

 0680:             bullets_remaining=self.bullets_remaining,

 0681:             mines_remaining=self.mines_remaining,

 0682:             can_fire=self.can_fire,

 0683:             fire_rate=self.fire_rate,

 0684:             can_deploy_mine=self.can_deploy_mine,

 0685:             mine_deploy_rate=self.mine_deploy_rate,

 0686:             thrust_range=self.thrust_range,

 0687:             turn_rate_range=self.turn_rate_range,

 0688:             max_speed=self.max_speed,

 0689:             drag=self.drag

 0690:         )

 0691: 

 0692:     def __eq__(self, other: object) -> bool:

 0693:         if not isinstance(other, Ship):

 0694:             return NotImplemented

 0695:         return (self.is_respawning == other.is_respawning and

 0696:                 self.position == other.position and

 0697:                 self.velocity == other.velocity and

 0698:                 self.speed == other.speed and

 0699:                 self.heading == other.heading and

 0700:                 self.mass == other.mass and

 0701:                 self.radius == other.radius and

 0702:                 self.id == other.id and

 0703:                 self.team == other.team and

 0704:                 self.lives_remaining == other.lives_remaining and

 0705:                 self.bullets_remaining == other.bullets_remaining and

 0706:                 self.mines_remaining == other.mines_remaining and

 0707:                 #self.can_fire == other.can_fire and

 0708:                 self.fire_rate == other.fire_rate and

 0709:                 #self.can_deploy_mine == other.can_deploy_mine and

 0710:                 self.mine_deploy_rate == other.mine_deploy_rate and

 0711:                 self.thrust_range == other.thrust_range and

 0712:                 self.turn_rate_range == other.turn_rate_range and

 0713:                 self.max_speed == other.max_speed and

 0714:                 self.drag == other.drag)

 0715: '''

 0716: 

+0717: cdef class Mine:

struct __pyx_obj_14neo_controller_Mine {
  PyObject_HEAD
  double pos_x;
  double pos_y;
  double mass;
  double fuse_time;
  double remaining_time;
};

+0718:     cdef public double pos_x, pos_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_5pos_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_5pos_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_5pos_x___get__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_5pos_x___get__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Mine.pos_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Mine_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Mine_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_5pos_x_2__set__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Mine_5pos_x_2__set__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 718, __pyx_L1_error)
  __pyx_v_self->pos_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Mine.pos_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_5pos_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_5pos_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_5pos_y___get__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_5pos_y___get__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Mine.pos_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Mine_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Mine_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_5pos_y_2__set__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Mine_5pos_y_2__set__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 718, __pyx_L1_error)
  __pyx_v_self->pos_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Mine.pos_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0719:     cdef public double mass

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_4mass_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_4mass_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_4mass___get__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_4mass___get__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 719, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Mine.mass.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Mine_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Mine_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_4mass_2__set__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Mine_4mass_2__set__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 719, __pyx_L1_error)
  __pyx_v_self->mass = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Mine.mass.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0720:     cdef public double fuse_time

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_9fuse_time_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_9fuse_time_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_9fuse_time___get__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_9fuse_time___get__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->fuse_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 720, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Mine.fuse_time.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Mine_9fuse_time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Mine_9fuse_time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_9fuse_time_2__set__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Mine_9fuse_time_2__set__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 720, __pyx_L1_error)
  __pyx_v_self->fuse_time = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Mine.fuse_time.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0721:     cdef public double remaining_time

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_14remaining_time_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_14remaining_time_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_14remaining_time___get__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_14remaining_time___get__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->remaining_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 721, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Mine.remaining_time.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Mine_14remaining_time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_4Mine_14remaining_time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_14remaining_time_2__set__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Mine_14remaining_time_2__set__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 721, __pyx_L1_error)
  __pyx_v_self->remaining_time = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Mine.remaining_time.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 0722: 

+0723:     def __cinit__(self,

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Mine_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_4Mine_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_position = 0;
  double __pyx_v_mass;
  double __pyx_v_fuse_time;
  double __pyx_v_remaining_time;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_position,&__pyx_mstate_global->__pyx_n_u_mass,&__pyx_mstate_global->__pyx_n_u_fuse_time,&__pyx_mstate_global->__pyx_n_u_remaining_time,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 723, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 723, __pyx_L3_error)
/* … */
  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Mine___cinit__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_position, double __pyx_v_mass, double __pyx_v_fuse_time, double __pyx_v_remaining_time) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Mine.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0724:                   position=(0.0, 0.0),

      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
    }
    __pyx_v_position = values[0];
    if (values[1]) {
      __pyx_v_mass = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_mass == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 725, __pyx_L3_error)
    } else {
      __pyx_v_mass = ((double)0.0);
    }
    if (values[2]) {
      __pyx_v_fuse_time = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_fuse_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 726, __pyx_L3_error)
    } else {
      __pyx_v_fuse_time = ((double)0.0);
    }
    if (values[3]) {
      __pyx_v_remaining_time = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_remaining_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 727, __pyx_L3_error)
    } else {
      __pyx_v_remaining_time = ((double)0.0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 4, __pyx_nargs); __PYX_ERR(0, 723, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Mine.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_4Mine___cinit__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), __pyx_v_position, __pyx_v_mass, __pyx_v_fuse_time, __pyx_v_remaining_time);

 0725:                   double mass=0.0,

 0726:                   double fuse_time=0.0,

 0727:                   double remaining_time=0.0):

+0728:         self.pos_x = position[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 728, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 728, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_x = __pyx_t_2;

+0729:         self.pos_y = position[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 729, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_y = __pyx_t_2;

+0730:         self.mass = mass

  __pyx_v_self->mass = __pyx_v_mass;

+0731:         self.fuse_time = fuse_time

  __pyx_v_self->fuse_time = __pyx_v_fuse_time;

+0732:         self.remaining_time = remaining_time

  __pyx_v_self->remaining_time = __pyx_v_remaining_time;

 0733: 

 0734:     property position:

+0735:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_8position_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_8position_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_8position___get__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_8position___get__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Mine.position.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0736:             return (self.pos_x, self.pos_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 736, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 736, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0737:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_4Mine_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_4Mine_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_8position_2__set__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_4Mine_8position_2__set__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Mine.position.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0738:             self.pos_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 738, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 738, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_x = __pyx_t_2;

+0739:             self.pos_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 739, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_y = __pyx_t_2;

 0740: 

+0741:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_2__str__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_2__str__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.Mine.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0742:         return "Mine(position=(%f, %f), mass=%f, fuse_time=%f, remaining_time=%f)" % (

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_7, 11, 15 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 8 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 12 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 17 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6));
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 742, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

+0743:             self.pos_x, self.pos_y, self.mass, self.fuse_time, self.remaining_time

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->fuse_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->remaining_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Mine_position;
  __pyx_t_7[1] = __pyx_t_2;
  __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_7[3] = __pyx_t_3;
  __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_mass_3;
  __pyx_t_7[5] = __pyx_t_4;
  __pyx_t_7[6] = __pyx_mstate_global->__pyx_kp_u_fuse_time_2;
  __pyx_t_7[7] = __pyx_t_5;
  __pyx_t_7[8] = __pyx_mstate_global->__pyx_kp_u_remaining_time_2;
  __pyx_t_7[9] = __pyx_t_6;
  __pyx_t_7[10] = __pyx_mstate_global->__pyx_kp_u__2;

 0744:         )

 0745: 

+0746:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_4__repr__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_4__repr__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Mine.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0747:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 747, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0748: 

+0749:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_4Mine_7copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_4Mine_7copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_4Mine_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_4Mine_6copy(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_6copy(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.Mine.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_4Mine_7copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Mine_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Mine, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < 0) __PYX_ERR(0, 749, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0750:         return Mine(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Mine);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Mine); 

+0751:             position=(self.pos_x, self.pos_y),

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 751, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 751, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 751, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 751, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 751, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;

+0752:             mass=self.mass,

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 752, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+0753:             fuse_time=self.fuse_time,

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->fuse_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 753, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+0754:             remaining_time=self.remaining_time

  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_self->remaining_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 754, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_6, __pyx_t_9, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 750, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_5, __pyx_t_9, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 750, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fuse_time, __pyx_t_4, __pyx_t_9, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 750, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_remaining_time, __pyx_t_7, __pyx_t_9, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 750, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 750, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0755:         )

 0756: 

+0757:     def __eq__(self, other):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_4Mine_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/
static PyObject *__pyx_pw_14neo_controller_4Mine_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_4Mine_8__eq__(((struct __pyx_obj_14neo_controller_Mine *)__pyx_v_self), ((PyObject *)__pyx_v_other));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4Mine_8__eq__(struct __pyx_obj_14neo_controller_Mine *__pyx_v_self, PyObject *__pyx_v_other) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.Mine.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0758:         if not isinstance(other, Mine):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_14neo_controller_Mine); 
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+0759:             return NotImplemented

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_builtin_NotImplemented);
    __pyx_r = __pyx_builtin_NotImplemented;
    goto __pyx_L0;

+0760:         return (

  __Pyx_XDECREF(__pyx_r);

+0761:             (self.pos_x, self.pos_y) == other.position and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 761, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 761, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 761, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 761, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0762:             self.mass == other.mass and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 762, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 762, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0763:             self.fuse_time == other.fuse_time and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->fuse_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_fuse_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 763, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 763, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0764:             self.remaining_time == other.remaining_time

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->remaining_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 764, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_3 = __pyx_t_6;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_L4_bool_binop_done:;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 0765:         )

 0766: 

 0767: '''

 0768: class Mine:

 0769:     __slots__ = ('position', 'mass', 'fuse_time', 'remaining_time')

 0770: 

 0771:     def __init__(self, position: tuple[float, float] = (0.0, 0.0), mass: float = 0.0, fuse_time: float = 0.0, remaining_time: float = 0.0) -> None:

 0772:         self.position = position

 0773:         self.mass = mass

 0774:         self.fuse_time = fuse_time

 0775:         self.remaining_time = remaining_time

 0776: 

 0777:     def __str__(self) -> str:

 0778:         return f'Mine(position={self.position}, mass={self.mass}, fuse_time={self.fuse_time}, remaining_time={self.remaining_time})'

 0779: 

 0780:     def __repr__(self) -> str:

 0781:         return self.__str__()

 0782: 

 0783:     def copy(self) -> 'Mine':

 0784:         return Mine(

 0785:             position=self.position,

 0786:             mass=self.mass,

 0787:             fuse_time=self.fuse_time,

 0788:             remaining_time=self.remaining_time

 0789:         )

 0790: 

 0791:     def __eq__(self, other: object) -> bool:

 0792:         if not isinstance(other, Mine):

 0793:             return NotImplemented

 0794:         return (self.position == other.position and

 0795:                 self.mass == other.mass and

 0796:                 self.fuse_time == other.fuse_time and

 0797:                 self.remaining_time == other.remaining_time)

 0798: '''

 0799: 

+0800: cdef class Bullet:

struct __pyx_obj_14neo_controller_Bullet {
  PyObject_HEAD
  double pos_x;
  double pos_y;
  double vel_x;
  double vel_y;
  double heading;
  double mass;
  double tail_dx;
  double tail_dy;
  double angle;
};

+0801:     cdef public double pos_x, pos_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_5pos_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_5pos_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5pos_x___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_5pos_x___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 801, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.pos_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_5pos_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5pos_x_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_5pos_x_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 801, __pyx_L1_error)
  __pyx_v_self->pos_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.pos_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_5pos_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_5pos_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5pos_y___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_5pos_y___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 801, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.pos_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_5pos_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5pos_y_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_5pos_y_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 801, __pyx_L1_error)
  __pyx_v_self->pos_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.pos_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0802:     cdef public double vel_x, vel_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_5vel_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_5vel_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5vel_x___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_5vel_x___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 802, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.vel_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_5vel_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_5vel_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5vel_x_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_5vel_x_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 802, __pyx_L1_error)
  __pyx_v_self->vel_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.vel_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_5vel_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_5vel_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5vel_y___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_5vel_y___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 802, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.vel_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_5vel_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_5vel_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5vel_y_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_5vel_y_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 802, __pyx_L1_error)
  __pyx_v_self->vel_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.vel_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0803:     cdef public double heading

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_7heading_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_7heading_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_7heading___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_7heading___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 803, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.heading.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_7heading_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_7heading_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_7heading_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_7heading_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 803, __pyx_L1_error)
  __pyx_v_self->heading = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.heading.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0804:     cdef public double mass

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_4mass_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_4mass_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_4mass___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_4mass___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 804, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.mass.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_4mass_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_4mass_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_4mass_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 804, __pyx_L1_error)
  __pyx_v_self->mass = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.mass.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0805:     cdef public double tail_dx, tail_dy

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_7tail_dx_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_7tail_dx_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_7tail_dx___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_7tail_dx___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->tail_dx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.tail_dx.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_7tail_dx_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_7tail_dx_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_7tail_dx_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_7tail_dx_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 805, __pyx_L1_error)
  __pyx_v_self->tail_dx = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.tail_dx.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_7tail_dy_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_7tail_dy_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_7tail_dy___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_7tail_dy___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->tail_dy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.tail_dy.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_7tail_dy_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_7tail_dy_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_7tail_dy_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_7tail_dy_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 805, __pyx_L1_error)
  __pyx_v_self->tail_dy = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.tail_dy.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+0806:     cdef public double angle

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_5angle_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_5angle_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5angle___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_5angle___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->angle); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 806, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.angle.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_5angle_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_5angle_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_5angle_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_5angle_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 806, __pyx_L1_error)
  __pyx_v_self->angle = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Bullet.angle.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 0807: 

+0808:     def __cinit__(self,

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_position = 0;
  PyObject *__pyx_v_velocity = 0;
  double __pyx_v_heading;
  double __pyx_v_mass;
  PyObject *__pyx_v_tail_delta = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_position,&__pyx_mstate_global->__pyx_n_u_velocity,&__pyx_mstate_global->__pyx_n_u_heading,&__pyx_mstate_global->__pyx_n_u_mass,&__pyx_mstate_global->__pyx_n_u_tail_delta,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 808, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 808, __pyx_L3_error)
/* … */
  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet___cinit__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_position, PyObject *__pyx_v_velocity, double __pyx_v_heading, double __pyx_v_mass, PyObject *__pyx_v_tail_delta) {
  PyObject *__pyx_v_angle = NULL;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.Bullet.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_angle);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0809:                   position=(0.0, 0.0),

      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
/* … */
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));

+0810:                   velocity=(0.0, 0.0),

      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
/* … */
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));

 0811:                   double heading=0.0,

+0812:                   double mass=BULLET_MASS,

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 812, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_mstate_global->__pyx_k__8 = __pyx_t_7;

+0813:                   tail_delta=None):

      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_None));
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 808, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
/* … */
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_position = values[0];
    __pyx_v_velocity = values[1];
    if (values[2]) {
      __pyx_v_heading = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_heading == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 811, __pyx_L3_error)
    } else {
      __pyx_v_heading = ((double)0.0);
    }
    if (values[3]) {
      __pyx_v_mass = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_mass == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 812, __pyx_L3_error)
    } else {
      __pyx_v_mass = __pyx_mstate_global->__pyx_k__8;
    }
    __pyx_v_tail_delta = values[4];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 5, __pyx_nargs); __PYX_ERR(0, 808, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Bullet.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Bullet___cinit__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), __pyx_v_position, __pyx_v_velocity, __pyx_v_heading, __pyx_v_mass, __pyx_v_tail_delta);

+0814:         self.pos_x = position[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 814, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 814, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_x = __pyx_t_2;

+0815:         self.pos_y = position[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 815, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 815, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_y = __pyx_t_2;

+0816:         self.vel_x = velocity[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_velocity, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 816, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 816, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_x = __pyx_t_2;

+0817:         self.vel_y = velocity[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_velocity, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 817, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 817, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_y = __pyx_t_2;

+0818:         self.heading = heading

  __pyx_v_self->heading = __pyx_v_heading;

+0819:         self.mass = mass

  __pyx_v_self->mass = __pyx_v_mass;

+0820:         if tail_delta is not None:

  __pyx_t_3 = (__pyx_v_tail_delta != Py_None);
  if (__pyx_t_3) {
/* … */
    goto __pyx_L3;
  }

+0821:             self.tail_dx = tail_delta[0]

    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tail_delta, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 821, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 821, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_self->tail_dx = __pyx_t_2;

+0822:             self.tail_dy = tail_delta[1]

    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tail_delta, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 822, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 822, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_self->tail_dy = __pyx_t_2;

 0823:         else:

+0824:             angle = radians(heading)

  /*else*/ {
    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 824, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 824, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 824, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_angle = __pyx_t_1;
    __pyx_t_1 = 0;

+0825:             self.tail_dx = -BULLET_LENGTH * cos(angle)

    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 825, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 825, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_angle); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 825, __pyx_L1_error)
    __pyx_t_1 = PyFloat_FromDouble(cos(__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 825, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 825, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 825, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_v_self->tail_dx = __pyx_t_2;

+0826:             self.tail_dy = -BULLET_LENGTH * sin(angle)

    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_1 = PyNumber_Negative(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_v_angle); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 826, __pyx_L1_error)
    __pyx_t_6 = PyFloat_FromDouble(sin(__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 826, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_v_self->tail_dy = __pyx_t_2;
  }
  __pyx_L3:;

 0827: 

 0828:     property position:

+0829:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_8position_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_8position_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_8position___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_8position___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Bullet.position.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0830:             return (self.pos_x, self.pos_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 830, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 830, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 830, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 830, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 830, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0831:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_8position_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_8position_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_8position_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.position.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0832:             self.pos_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 832, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 832, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_x = __pyx_t_2;

+0833:             self.pos_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 833, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->pos_y = __pyx_t_2;

 0834: 

 0835:     property velocity:

+0836:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_8velocity_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_8velocity_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_8velocity___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_8velocity___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Bullet.velocity.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0837:             return (self.vel_x, self.vel_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 837, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 837, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 837, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 837, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 837, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0838:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_8velocity_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_8velocity_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_8velocity_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_8velocity_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.velocity.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0839:             self.vel_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 839, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_x = __pyx_t_2;

+0840:             self.vel_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 840, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 840, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->vel_y = __pyx_t_2;

 0841: 

 0842:     property tail_delta:

+0843:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_10tail_delta_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_10tail_delta_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_10tail_delta___get__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_10tail_delta___get__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Bullet.tail_delta.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0844:             return (self.tail_dx, self.tail_dy)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->tail_dx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->tail_dy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 844, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 844, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+0845:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Bullet_10tail_delta_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_6Bullet_10tail_delta_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_10tail_delta_2__set__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Bullet_10tail_delta_2__set__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Bullet.tail_delta.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0846:             self.tail_dx = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 846, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->tail_dx = __pyx_t_2;

+0847:             self.tail_dy = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 847, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 847, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->tail_dy = __pyx_t_2;

 0848: 

+0849:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_2__str__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_2__str__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.Bullet.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0850:         return ("Bullet(position=(%f, %f), velocity=(%f, %f), heading=%f, mass=%f, tail_delta=(%f, %f))"

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_10, 17, 17 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 2 * 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 13 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 7 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 14 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

+0851:             % (self.pos_x, self.pos_y, self.vel_x, self.vel_y,

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+0852:                self.heading, self.mass, self.tail_dx, self.tail_dy))

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->tail_dx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_8 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->tail_dy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 852, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Bullet_position;
  __pyx_t_10[1] = __pyx_t_2;
  __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_10[3] = __pyx_t_3;
  __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_velocity_2;
  __pyx_t_10[5] = __pyx_t_4;
  __pyx_t_10[6] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_10[7] = __pyx_t_5;
  __pyx_t_10[8] = __pyx_mstate_global->__pyx_kp_u_heading_3;
  __pyx_t_10[9] = __pyx_t_6;
  __pyx_t_10[10] = __pyx_mstate_global->__pyx_kp_u_mass_2;
  __pyx_t_10[11] = __pyx_t_7;
  __pyx_t_10[12] = __pyx_mstate_global->__pyx_kp_u_tail_delta_2;
  __pyx_t_10[13] = __pyx_t_8;
  __pyx_t_10[14] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_10[15] = __pyx_t_9;
  __pyx_t_10[16] = __pyx_mstate_global->__pyx_kp_u__9;

 0853: 

+0854:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_4__repr__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_4__repr__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Bullet.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0855:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 855, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0856: 

+0857:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Bullet_7copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Bullet_7copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Bullet_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_6copy(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_6copy(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Bullet.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Bullet_7copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Bullet_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[55])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 857, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < 0) __PYX_ERR(0, 857, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0858:         return Bullet(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet); 

+0859:             position=(self.pos_x, self.pos_y),

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 859, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 859, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;

+0860:             velocity=(self.vel_x, self.vel_y),

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 860, __pyx_L1_error);
  __pyx_t_5 = 0;
  __pyx_t_4 = 0;

+0861:             heading=self.heading,

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+0862:             mass=self.mass,

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 862, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+0863:             tail_delta=(self.tail_dx, self.tail_dy)

  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_self->tail_dx); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 863, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_self->tail_dy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 863, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 863, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 863, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 863, __pyx_L1_error);
  __pyx_t_8 = 0;
  __pyx_t_9 = 0;
  __pyx_t_11 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 858, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_6, __pyx_t_9, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 858, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_7, __pyx_t_9, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 858, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_heading, __pyx_t_4, __pyx_t_9, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 858, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_5, __pyx_t_9, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 858, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_tail_delta, __pyx_t_10, __pyx_t_9, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 858, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 858, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0864:         )

 0865: 

+0866:     def __eq__(self, other):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Bullet_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Bullet_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Bullet_8__eq__(((struct __pyx_obj_14neo_controller_Bullet *)__pyx_v_self), ((PyObject *)__pyx_v_other));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Bullet_8__eq__(struct __pyx_obj_14neo_controller_Bullet *__pyx_v_self, PyObject *__pyx_v_other) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.Bullet.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0867:         if not isinstance(other, Bullet):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet); 
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+0868:             return NotImplemented

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_builtin_NotImplemented);
    __pyx_r = __pyx_builtin_NotImplemented;
    goto __pyx_L0;

+0869:         return ((self.pos_x, self.pos_y) == other.position and

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 869, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 869, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 869, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0870:                 (self.vel_x, self.vel_y) == other.velocity and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->vel_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->vel_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 870, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 870, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 870, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 870, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0871:                 self.heading == other.heading and

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 871, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 871, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0872:                 self.mass == other.mass and

  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->mass); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 872, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 872, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 872, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 872, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_bool_binop_done;
  }

+0873:                 (self.tail_dx, self.tail_dy) == other.tail_delta)

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->tail_dx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->tail_dy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 873, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 873, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_tail_delta); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 873, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_3 = __pyx_t_4;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_L4_bool_binop_done:;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 0874: 

 0875: 

 0876: '''

 0877: class Bullet:

 0878:     __slots__ = ('position', 'velocity', 'heading', 'mass', 'tail_delta')

 0879: 

 0880:     def __init__(self, position: tuple[float, float] = (0.0, 0.0), velocity: tuple[float, float] = (0.0, 0.0), heading: float = 0.0, mass: float = BULLET_MASS, tail_delta: Optional[tuple[float, float]] = None) -> None:

 0881:         self.position = position

 0882:         self.velocity = velocity

 0883:         self.heading = heading

 0884:         self.mass = mass

 0885:         if tail_delta is not None:

 0886:             self.tail_delta = tail_delta

 0887:         else:

 0888:             self.tail_delta = (-BULLET_LENGTH*cos(radians(heading)), -BULLET_LENGTH*sin(radians(heading)))

 0889: 

 0890:     def __str__(self) -> str:

 0891:         return f'Bullet(position={self.position}, velocity={self.velocity}, heading={self.heading}, mass={self.mass}, tail_delta={self.tail_delta})'

 0892: 

 0893:     def __repr__(self) -> str:

 0894:         return self.__str__()

 0895: 

 0896:     def copy(self) -> 'Bullet':

 0897:         return Bullet(

 0898:             position=self.position,

 0899:             velocity=self.velocity,

 0900:             heading=self.heading,

 0901:             mass=self.mass,

 0902:             tail_delta=self.tail_delta

 0903:         )

 0904: 

 0905:     def __eq__(self, other: object) -> bool:

 0906:         if not isinstance(other, Bullet):

 0907:             return NotImplemented

 0908:         return (self.position == other.position and

 0909:                 self.velocity == other.velocity and

 0910:                 self.heading == other.heading and

 0911:                 self.mass == other.mass and

 0912:                 self.tail_delta == other.tail_delta)

 0913: '''

 0914: 

 0915: 

 0916: 

 0917: '''

 0918: class GameState:

 0919:     __slots__ = ('asteroids', 'ships', 'bullets', 'mines', 'map_size', 'time', 'delta_time', 'sim_frame', 'time_limit')

 0920: 

 0921:     def __init__(self, asteroids: list[Asteroid], ships: list[Ship], bullets: list[Bullet], mines: list[Mine], map_size: tuple[float, float] = (0.0, 0.0), time: float = 0.0, delta_time: float = 0.0, sim_frame: int = 0, time_limit: float = 0.0) -> None:

 0922:         self.asteroids = asteroids

 0923:         self.ships = ships

 0924:         self.bullets = bullets

 0925:         self.mines = mines

 0926:         self.map_size = map_size

 0927:         self.time = time

 0928:         self.delta_time = delta_time

 0929:         self.sim_frame = sim_frame

 0930:         self.time_limit = time_limit

 0931: 

 0932:     def __str__(self) -> str:

 0933:         return f'GameState(asteroids={self.asteroids}, ships={self.ships}, bullets={self.bullets}, mines={self.mines}, map_size={self.map_size}, time={self.time}, delta_time={self.delta_time}, sim_frame={self.sim_frame}, time_limit={self.time_limit})'

 0934: 

 0935:     def __repr__(self) -> str:

 0936:         return self.__str__()

 0937: 

 0938:     def copy(self) -> 'GameState':

 0939:         return GameState(

 0940:             asteroids=[asteroid.copy() for asteroid in self.asteroids], 

 0941:             ships=[ship.copy() for ship in self.ships], 

 0942:             bullets=[bullet.copy() for bullet in self.bullets], 

 0943:             mines=[mine.copy() for mine in self.mines], 

 0944:             map_size=self.map_size, 

 0945:             time=self.time, 

 0946:             delta_time=self.delta_time, 

 0947:             sim_frame=self.sim_frame,

 0948:             time_limit=self.time_limit

 0949:         )

 0950:     

 0951:     def __eq__(self, other: object) -> bool:

 0952:         if not isinstance(other, GameState):

 0953:             return NotImplemented

 0954:         

 0955:         # Compare asteroids

 0956:         if len(self.asteroids) != len(other.asteroids):

 0957:             print("Asteroids lists are different lengths!")

 0958:             return False

 0959:         for i, (ast_a, ast_b) in enumerate(zip(self.asteroids, other.asteroids)):

 0960:             if ast_a != ast_b:

 0961:                 print(f"Asteroids don't match at index {i}: {ast_a} vs {ast_b}")

 0962:                 return False

 0963:         

 0964:         # Compare bullets

 0965:         if len(self.bullets) != len(other.bullets):

 0966:             print("Bullet lists are different lengths!")

 0967:             return False

 0968:         for i, (bul_a, bul_b) in enumerate(zip(self.bullets, other.bullets)):

 0969:             if bul_a != bul_b:

 0970:                 print(f"Bullets don't match at index {i}: {bul_a} vs {bul_b}")

 0971:                 return False

 0972:         

 0973:         # Compare mines

 0974:         if len(self.mines) != len(other.mines):

 0975:             print("Mine lists are different lengths!")

 0976:             return False

 0977:         for i, (mine_a, mine_b) in enumerate(zip(self.mines, other.mines)):

 0978:             if mine_a != mine_b:

 0979:                 print(f"Mines don't match at index {i}: {mine_a} vs {mine_b}")

 0980:                 return False

 0981:         

 0982:         # Compare ships

 0983:         #if len(self.ships) != len(other.ships):

 0984:         #    print("Ships lists are different lengths!")

 0985:         #    return False

 0986:         #for i, (ship_a, ship_b) in enumerate(zip(self.ships, other.ships)):

 0987:         #    if ship_a != ship_b:

 0988:         #        print(f"Ships don't match at index {i}: {ship_a} vs {ship_b}")

 0989:         #        return False

 0990:         

 0991:         # Trivial properties like timesteps are not compared, assuming they don't affect game state equality

 0992:         return True

 0993: '''

 0994: 

+0995: cdef class GameState:

struct __pyx_obj_14neo_controller_GameState {
  PyObject_HEAD
  PyObject *asteroids;
  PyObject *ships;
  PyObject *bullets;
  PyObject *mines;
  double map_size_x;
  double map_size_y;
  double time;
  double delta_time;
  int sim_frame;
  double time_limit;
};

+0996:     cdef public list asteroids  # list of Asteroid

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_9asteroids_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_9asteroids_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_9asteroids___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_9asteroids___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->asteroids);
  __pyx_r = __pyx_v_self->asteroids;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_9asteroids_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_9asteroids_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_9asteroids_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_9asteroids_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 996, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->asteroids);
  __Pyx_DECREF(__pyx_v_self->asteroids);
  __pyx_v_self->asteroids = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.asteroids.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_9asteroids_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_9asteroids_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_9asteroids_4__del__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_9asteroids_4__del__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->asteroids);
  __Pyx_DECREF(__pyx_v_self->asteroids);
  __pyx_v_self->asteroids = ((PyObject*)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0997:     cdef public list ships      # list of Ship

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_5ships_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_5ships_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_5ships___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_5ships___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->ships);
  __pyx_r = __pyx_v_self->ships;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_5ships_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_5ships_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_5ships_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_5ships_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 997, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->ships);
  __Pyx_DECREF(__pyx_v_self->ships);
  __pyx_v_self->ships = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.ships.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_5ships_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_5ships_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_5ships_4__del__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_5ships_4__del__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->ships);
  __Pyx_DECREF(__pyx_v_self->ships);
  __pyx_v_self->ships = ((PyObject*)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0998:     cdef public list bullets    # list of Bullet

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_7bullets_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_7bullets_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_7bullets___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_7bullets___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->bullets);
  __pyx_r = __pyx_v_self->bullets;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_7bullets_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_7bullets_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_7bullets_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_7bullets_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 998, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->bullets);
  __Pyx_DECREF(__pyx_v_self->bullets);
  __pyx_v_self->bullets = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.bullets.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_7bullets_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_7bullets_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_7bullets_4__del__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_7bullets_4__del__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->bullets);
  __Pyx_DECREF(__pyx_v_self->bullets);
  __pyx_v_self->bullets = ((PyObject*)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0999:     cdef public list mines      # list of Mine

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_5mines_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_5mines_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_5mines___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_5mines___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->mines);
  __pyx_r = __pyx_v_self->mines;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_5mines_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_5mines_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_5mines_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_5mines_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 999, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->mines);
  __Pyx_DECREF(__pyx_v_self->mines);
  __pyx_v_self->mines = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.mines.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_5mines_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_5mines_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_5mines_4__del__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_5mines_4__del__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->mines);
  __Pyx_DECREF(__pyx_v_self->mines);
  __pyx_v_self->mines = ((PyObject*)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1000:     cdef public double map_size_x, map_size_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_10map_size_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_10map_size_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10map_size_x___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_10map_size_x___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->map_size_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1000, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.map_size_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_10map_size_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_10map_size_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10map_size_x_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_10map_size_x_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1000, __pyx_L1_error)
  __pyx_v_self->map_size_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.GameState.map_size_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_10map_size_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_10map_size_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10map_size_y___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_10map_size_y___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->map_size_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1000, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.map_size_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_10map_size_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_10map_size_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10map_size_y_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_10map_size_y_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1000, __pyx_L1_error)
  __pyx_v_self->map_size_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.GameState.map_size_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1001:     cdef public double time

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_4time_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_4time_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_4time___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_4time___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1001, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.time.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_4time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_4time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_4time_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_4time_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1001, __pyx_L1_error)
  __pyx_v_self->time = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.GameState.time.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1002:     cdef public double delta_time

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_10delta_time_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_10delta_time_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10delta_time___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_10delta_time___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->delta_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1002, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.delta_time.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_10delta_time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_10delta_time_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10delta_time_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_10delta_time_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1002, __pyx_L1_error)
  __pyx_v_self->delta_time = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.GameState.delta_time.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1003:     cdef public int sim_frame

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_9sim_frame_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_9sim_frame_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_9sim_frame___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_9sim_frame___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->sim_frame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1003, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.sim_frame.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_9sim_frame_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_9sim_frame_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_9sim_frame_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_9sim_frame_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1003, __pyx_L1_error)
  __pyx_v_self->sim_frame = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.GameState.sim_frame.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1004:     cdef public double time_limit

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_10time_limit_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_10time_limit_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10time_limit___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_10time_limit___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->time_limit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1004, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.time_limit.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_10time_limit_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_10time_limit_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_10time_limit_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_10time_limit_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1004, __pyx_L1_error)
  __pyx_v_self->time_limit = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.GameState.time_limit.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 1005: 

+1006:     def __cinit__(self,

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_asteroids = 0;
  PyObject *__pyx_v_ships = 0;
  PyObject *__pyx_v_bullets = 0;
  PyObject *__pyx_v_mines = 0;
  PyObject *__pyx_v_map_size = 0;
  double __pyx_v_time;
  double __pyx_v_delta_time;
  int __pyx_v_sim_frame;
  double __pyx_v_time_limit;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroids,&__pyx_mstate_global->__pyx_n_u_ships,&__pyx_mstate_global->__pyx_n_u_bullets,&__pyx_mstate_global->__pyx_n_u_mines,&__pyx_mstate_global->__pyx_n_u_map_size,&__pyx_mstate_global->__pyx_n_u_time,&__pyx_mstate_global->__pyx_n_u_delta_time,&__pyx_mstate_global->__pyx_n_u_sim_frame,&__pyx_mstate_global->__pyx_n_u_time_limit,0};
  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1006, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  9:
        values[8] = __Pyx_ArgRef_VARARGS(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_VARARGS(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 1006, __pyx_L3_error)
/* … */
  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState___cinit__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_asteroids, PyObject *__pyx_v_ships, PyObject *__pyx_v_bullets, PyObject *__pyx_v_mines, PyObject *__pyx_v_map_size, double __pyx_v_time, double __pyx_v_delta_time, int __pyx_v_sim_frame, double __pyx_v_time_limit) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1007:                   asteroids,

 1008:                   ships,

 1009:                   bullets,

 1010:                   mines,

+1011:                   map_size=(0.0, 0.0),

      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 9, i); __PYX_ERR(0, 1006, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  9:
        values[8] = __Pyx_ArgRef_VARARGS(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_VARARGS(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1006, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1006, __pyx_L3_error)
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1006, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1006, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1006, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_tuple[0]));
    }
    __pyx_v_asteroids = values[0];
    __pyx_v_ships = values[1];
    __pyx_v_bullets = values[2];
    __pyx_v_mines = values[3];
    __pyx_v_map_size = values[4];
    if (values[5]) {
      __pyx_v_time = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1012, __pyx_L3_error)
    } else {
      __pyx_v_time = ((double)0.0);
    }
    if (values[6]) {
      __pyx_v_delta_time = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_delta_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1013, __pyx_L3_error)
    } else {
      __pyx_v_delta_time = ((double)0.0);
    }
    if (values[7]) {
      __pyx_v_sim_frame = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_sim_frame == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1014, __pyx_L3_error)
    } else {
      __pyx_v_sim_frame = ((int)0);
    }
    if (values[8]) {
      __pyx_v_time_limit = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_time_limit == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1015, __pyx_L3_error)
    } else {
      __pyx_v_time_limit = ((double)0.0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 4, 9, __pyx_nargs); __PYX_ERR(0, 1006, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.GameState.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_9GameState___cinit__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), __pyx_v_asteroids, __pyx_v_ships, __pyx_v_bullets, __pyx_v_mines, __pyx_v_map_size, __pyx_v_time, __pyx_v_delta_time, __pyx_v_sim_frame, __pyx_v_time_limit);

 1012:                   double time=0.0,

 1013:                   double delta_time=0.0,

 1014:                   int sim_frame=0,

 1015:                   double time_limit=0.0):

+1016:         self.asteroids = asteroids

  __pyx_t_1 = __pyx_v_asteroids;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 1016, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->asteroids);
  __Pyx_DECREF(__pyx_v_self->asteroids);
  __pyx_v_self->asteroids = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1017:         self.ships = ships

  __pyx_t_1 = __pyx_v_ships;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 1017, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->ships);
  __Pyx_DECREF(__pyx_v_self->ships);
  __pyx_v_self->ships = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1018:         self.bullets = bullets

  __pyx_t_1 = __pyx_v_bullets;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 1018, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->bullets);
  __Pyx_DECREF(__pyx_v_self->bullets);
  __pyx_v_self->bullets = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1019:         self.mines = mines

  __pyx_t_1 = __pyx_v_mines;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 1019, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->mines);
  __Pyx_DECREF(__pyx_v_self->mines);
  __pyx_v_self->mines = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1020:         self.map_size_x = map_size[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_map_size, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1020, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1020, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->map_size_x = __pyx_t_2;

+1021:         self.map_size_y = map_size[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_map_size, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1021, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1021, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->map_size_y = __pyx_t_2;

+1022:         self.time = time

  __pyx_v_self->time = __pyx_v_time;

+1023:         self.delta_time = delta_time

  __pyx_v_self->delta_time = __pyx_v_delta_time;

+1024:         self.sim_frame = sim_frame

  __pyx_v_self->sim_frame = __pyx_v_sim_frame;

+1025:         self.time_limit = time_limit

  __pyx_v_self->time_limit = __pyx_v_time_limit;

 1026: 

 1027:     property map_size:

+1028:         def __get__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_8map_size_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_8map_size_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_8map_size___get__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_8map_size___get__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.GameState.map_size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1029:             return (self.map_size_x, self.map_size_y)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->map_size_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1029, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_self->map_size_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1029, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1029, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1029, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1029, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+1030:         def __set__(self, v):

/* Python wrapper */
static int __pyx_pw_14neo_controller_9GameState_8map_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v); /*proto*/
static int __pyx_pw_14neo_controller_9GameState_8map_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_v) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_8map_size_2__set__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_v));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_9GameState_8map_size_2__set__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_v) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.GameState.map_size.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1031:             self.map_size_x = v[0]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1031, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1031, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->map_size_x = __pyx_t_2;

+1032:             self.map_size_y = v[1]

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1032, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1032, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->map_size_y = __pyx_t_2;

 1033: 

+1034:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_2__str__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_2__str__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.GameState.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1035:         return ("GameState(asteroids=%s, ships=%s, bullets=%s, mines=%s, map_size=(%f, %f), time=%f, delta_time=%f, sim_frame=%d, time_limit=%f)" %

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_12, 21, 20 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 8 * 3 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 12 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 13 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_11) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_11));
  if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1035, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __pyx_r = __pyx_t_10;
  __pyx_t_10 = 0;
  goto __pyx_L0;

+1036:                 (self.asteroids, self.ships, self.bullets, self.mines,

  __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->asteroids), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1036, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->ships), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1036, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->bullets), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1036, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_self->mines), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1036, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+1037:                  self.map_size_x, self.map_size_y, self.time, self.delta_time, self.sim_frame, self.time_limit))

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->map_size_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->map_size_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->delta_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyUnicode_From_int(__pyx_v_self->sim_frame, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_self->time_limit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_11 = __Pyx_PyObject_Format(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_12[0] = __pyx_mstate_global->__pyx_kp_u_GameState_asteroids;
  __pyx_t_12[1] = __pyx_t_1;
  __pyx_t_12[2] = __pyx_mstate_global->__pyx_kp_u_ships_2;
  __pyx_t_12[3] = __pyx_t_2;
  __pyx_t_12[4] = __pyx_mstate_global->__pyx_kp_u_bullets_2;
  __pyx_t_12[5] = __pyx_t_3;
  __pyx_t_12[6] = __pyx_mstate_global->__pyx_kp_u_mines_2;
  __pyx_t_12[7] = __pyx_t_4;
  __pyx_t_12[8] = __pyx_mstate_global->__pyx_kp_u_map_size_2;
  __pyx_t_12[9] = __pyx_t_6;
  __pyx_t_12[10] = __pyx_mstate_global->__pyx_kp_u_;
  __pyx_t_12[11] = __pyx_t_7;
  __pyx_t_12[12] = __pyx_mstate_global->__pyx_kp_u_time_2;
  __pyx_t_12[13] = __pyx_t_8;
  __pyx_t_12[14] = __pyx_mstate_global->__pyx_kp_u_delta_time_2;
  __pyx_t_12[15] = __pyx_t_9;
  __pyx_t_12[16] = __pyx_mstate_global->__pyx_kp_u_sim_frame_2;
  __pyx_t_12[17] = __pyx_t_5;
  __pyx_t_12[18] = __pyx_mstate_global->__pyx_kp_u_time_limit_2;
  __pyx_t_12[19] = __pyx_t_11;
  __pyx_t_12[20] = __pyx_mstate_global->__pyx_kp_u__2;

 1038: 

+1039:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_4__repr__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_4__repr__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.GameState.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1040:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1040, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1041: 

+1042:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_9GameState_7copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_9GameState_7copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_9GameState_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_9GameState_6copy(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_6copy(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self) {
  PyObject *__pyx_8genexpr3__pyx_v_asteroid = NULL;
  PyObject *__pyx_8genexpr4__pyx_v_ship = NULL;
  PyObject *__pyx_8genexpr5__pyx_v_bullet = NULL;
  PyObject *__pyx_8genexpr6__pyx_v_mine = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("neo_controller.GameState.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_ship);
  __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_bullet);
  __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_mine);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_9GameState_7copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_GameState_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1042, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < 0) __PYX_ERR(0, 1042, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1043:         # List comprehensions call the copy() method for each object, preserving type

+1044:         return GameState(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState); 
  { /* enter inner scope */

+1045:             asteroids=[asteroid.copy() for asteroid in self.asteroids],

    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1045, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(__pyx_v_self->asteroids == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 1045, __pyx_L5_error)
    }
    __pyx_t_5 = __pyx_v_self->asteroids; __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1045, __pyx_L5_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1045, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_asteroid, __pyx_t_7);
      __pyx_t_7 = 0;
      __pyx_t_8 = __pyx_8genexpr3__pyx_v_asteroid;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
        __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1045, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 1045, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_asteroid); __pyx_8genexpr3__pyx_v_asteroid = 0;
    goto __pyx_L9_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_asteroid); __pyx_8genexpr3__pyx_v_asteroid = 0;
    goto __pyx_L1_error;
    __pyx_L9_exit_scope:;
  } /* exit inner scope */
  { /* enter inner scope */

+1046:             ships=[ship.copy() for ship in self.ships],

    __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1046, __pyx_L12_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (unlikely(__pyx_v_self->ships == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 1046, __pyx_L12_error)
    }
    __pyx_t_7 = __pyx_v_self->ships; __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1046, __pyx_L12_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1046, __pyx_L12_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_XDECREF_SET(__pyx_8genexpr4__pyx_v_ship, __pyx_t_8);
      __pyx_t_8 = 0;
      __pyx_t_10 = __pyx_8genexpr4__pyx_v_ship;
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
        __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1046, __pyx_L12_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 1046, __pyx_L12_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    }
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_ship); __pyx_8genexpr4__pyx_v_ship = 0;
    goto __pyx_L16_exit_scope;
    __pyx_L12_error:;
    __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_ship); __pyx_8genexpr4__pyx_v_ship = 0;
    goto __pyx_L1_error;
    __pyx_L16_exit_scope:;
  } /* exit inner scope */
  { /* enter inner scope */

+1047:             bullets=[bullet.copy() for bullet in self.bullets],

    __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1047, __pyx_L19_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (unlikely(__pyx_v_self->bullets == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 1047, __pyx_L19_error)
    }
    __pyx_t_8 = __pyx_v_self->bullets; __Pyx_INCREF(__pyx_t_8);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1047, __pyx_L19_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_10 = __Pyx_PyList_GetItemRef(__pyx_t_8, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1047, __pyx_L19_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_XDECREF_SET(__pyx_8genexpr5__pyx_v_bullet, __pyx_t_10);
      __pyx_t_10 = 0;
      __pyx_t_11 = __pyx_8genexpr5__pyx_v_bullet;
      __Pyx_INCREF(__pyx_t_11);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_11, NULL};
        __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1047, __pyx_L19_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_10))) __PYX_ERR(0, 1047, __pyx_L19_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    }
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_bullet); __pyx_8genexpr5__pyx_v_bullet = 0;
    goto __pyx_L23_exit_scope;
    __pyx_L19_error:;
    __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_bullet); __pyx_8genexpr5__pyx_v_bullet = 0;
    goto __pyx_L1_error;
    __pyx_L23_exit_scope:;
  } /* exit inner scope */
  { /* enter inner scope */

+1048:             mines=[mine.copy() for mine in self.mines],

    __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1048, __pyx_L26_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (unlikely(__pyx_v_self->mines == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 1048, __pyx_L26_error)
    }
    __pyx_t_10 = __pyx_v_self->mines; __Pyx_INCREF(__pyx_t_10);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1048, __pyx_L26_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_11 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1048, __pyx_L26_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_XDECREF_SET(__pyx_8genexpr6__pyx_v_mine, __pyx_t_11);
      __pyx_t_11 = 0;
      __pyx_t_12 = __pyx_8genexpr6__pyx_v_mine;
      __Pyx_INCREF(__pyx_t_12);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL};
        __pyx_t_11 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1048, __pyx_L26_error)
        __Pyx_GOTREF(__pyx_t_11);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_8, (PyObject*)__pyx_t_11))) __PYX_ERR(0, 1048, __pyx_L26_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    }
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_mine); __pyx_8genexpr6__pyx_v_mine = 0;
    goto __pyx_L30_exit_scope;
    __pyx_L26_error:;
    __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_mine); __pyx_8genexpr6__pyx_v_mine = 0;
    goto __pyx_L1_error;
    __pyx_L30_exit_scope:;
  } /* exit inner scope */

+1049:             map_size=(self.map_size_x, self.map_size_y),

  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_self->map_size_x); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1049, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_11 = PyFloat_FromDouble(__pyx_v_self->map_size_y); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1049, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1049, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_GIVEREF(__pyx_t_10);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10) != (0)) __PYX_ERR(0, 1049, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_11);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_11) != (0)) __PYX_ERR(0, 1049, __pyx_L1_error);
  __pyx_t_10 = 0;
  __pyx_t_11 = 0;

+1050:             time=self.time,

  __pyx_t_11 = PyFloat_FromDouble(__pyx_v_self->time); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1050, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);

+1051:             delta_time=self.delta_time,

  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_self->delta_time); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1051, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);

+1052:             sim_frame=self.sim_frame,

  __pyx_t_13 = __Pyx_PyLong_From_int(__pyx_v_self->sim_frame); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);

+1053:             time_limit=self.time_limit

  __pyx_t_14 = PyFloat_FromDouble(__pyx_v_self->time_limit); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1053, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_9 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 9 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_15 = __Pyx_MakeVectorcallBuilderKwds(9); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1044, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_4, __pyx_t_15, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ships, __pyx_t_5, __pyx_t_15, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_7, __pyx_t_15, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mines, __pyx_t_8, __pyx_t_15, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_map_size, __pyx_t_12, __pyx_t_15, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_time, __pyx_t_11, __pyx_t_15, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_delta_time, __pyx_t_10, __pyx_t_15, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_sim_frame, __pyx_t_13, __pyx_t_15, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_time_limit, __pyx_t_14, __pyx_t_15, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 1044, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_15);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1044, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1054:         )

 1055: 

+1056:     def __eq__(self, other):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9GameState_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/
static PyObject *__pyx_pw_14neo_controller_9GameState_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_9GameState_8__eq__(((struct __pyx_obj_14neo_controller_GameState *)__pyx_v_self), ((PyObject *)__pyx_v_other));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_9GameState_8__eq__(struct __pyx_obj_14neo_controller_GameState *__pyx_v_self, PyObject *__pyx_v_other) {
  PyObject *__pyx_v_i = NULL;
  PyObject *__pyx_v_ast_a = NULL;
  PyObject *__pyx_v_ast_b = NULL;
  PyObject *__pyx_v_bul_a = NULL;
  PyObject *__pyx_v_bul_b = NULL;
  PyObject *__pyx_v_mine_a = NULL;
  PyObject *__pyx_v_mine_b = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_AddTraceback("neo_controller.GameState.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_i);
  __Pyx_XDECREF(__pyx_v_ast_a);
  __Pyx_XDECREF(__pyx_v_ast_b);
  __Pyx_XDECREF(__pyx_v_bul_a);
  __Pyx_XDECREF(__pyx_v_bul_b);
  __Pyx_XDECREF(__pyx_v_mine_a);
  __Pyx_XDECREF(__pyx_v_mine_b);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1057:         if not isinstance(other, GameState):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState); 
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+1058:             return NotImplemented

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_builtin_NotImplemented);
    __pyx_r = __pyx_builtin_NotImplemented;
    goto __pyx_L0;

 1059: 

 1060:         # Compare asteroids

+1061:         if len(self.asteroids) != len(other.asteroids):

  __pyx_t_3 = __pyx_v_self->asteroids;
  __Pyx_INCREF(__pyx_t_3);
  if (unlikely(__pyx_t_3 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 1061, __pyx_L1_error)
  }
  __pyx_t_4 = __Pyx_PyList_GET_SIZE(__pyx_t_3); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1061, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1061, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1061, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_2 = (__pyx_t_4 != __pyx_t_5);
  if (__pyx_t_2) {
/* … */
  }

+1062:             print("Asteroids lists are different lengths!")

    __pyx_t_6 = NULL;
    __Pyx_INCREF(__pyx_builtin_print);
    __pyx_t_7 = __pyx_builtin_print; 
    __pyx_t_8 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_Asteroids_lists_are_different_le};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1062, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1063:             return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

+1064:         for i, (ast_a, ast_b) in enumerate(zip(self.asteroids, other.asteroids)):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_3 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_6 = NULL;
  __Pyx_INCREF(__pyx_builtin_zip);
  __pyx_t_9 = __pyx_builtin_zip; 
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1064, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_8 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_self->asteroids, __pyx_t_10};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1064, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }
  if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
    __pyx_t_9 = __pyx_t_7; __Pyx_INCREF(__pyx_t_9);
    __pyx_t_5 = 0;
    __pyx_t_11 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1064, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1064, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  for (;;) {
    if (likely(!__pyx_t_11)) {
      if (likely(PyList_CheckExact(__pyx_t_9))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1064, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_5);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1064, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_5));
        #else
        __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1064, __pyx_L1_error)
    } else {
      __pyx_t_7 = __pyx_t_11(__pyx_t_9);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1064, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_7);
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 1064, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_10);
        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_6);
      } else {
        __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1064, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_10);
        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1064, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_6);
      }
      #else
      __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1064, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1064, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_12 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1064, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_12);
      index = 0; __pyx_t_10 = __pyx_t_13(__pyx_t_12); if (unlikely(!__pyx_t_10)) goto __pyx_L7_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_10);
      index = 1; __pyx_t_6 = __pyx_t_13(__pyx_t_12); if (unlikely(!__pyx_t_6)) goto __pyx_L7_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_13(__pyx_t_12), 2) < 0) __PYX_ERR(0, 1064, __pyx_L1_error)
      __pyx_t_13 = NULL;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      goto __pyx_L8_unpacking_done;
      __pyx_L7_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_13 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 1064, __pyx_L1_error)
      __pyx_L8_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_ast_a, __pyx_t_10);
    __pyx_t_10 = 0;
    __Pyx_XDECREF_SET(__pyx_v_ast_b, __pyx_t_6);
    __pyx_t_6 = 0;
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
    __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1064, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3);
    __pyx_t_3 = __pyx_t_7;
    __pyx_t_7 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1065:             if ast_a != ast_b:

    __pyx_t_7 = PyObject_RichCompare(__pyx_v_ast_a, __pyx_v_ast_b, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1065, __pyx_L1_error)
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1065, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_2) {
/* … */
    }

+1066:                 print(f"Asteroids don't match at index {i}: {ast_a} vs {ast_b}")

      __pyx_t_6 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_10 = __pyx_builtin_print; 
      __pyx_t_12 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_14 = __Pyx_PyObject_FormatSimple(__pyx_v_ast_a, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_ast_b, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_16[0] = __pyx_mstate_global->__pyx_kp_u_Asteroids_don_t_match_at_index;
      __pyx_t_16[1] = __pyx_t_12;
      __pyx_t_16[2] = __pyx_mstate_global->__pyx_kp_u__10;
      __pyx_t_16[3] = __pyx_t_14;
      __pyx_t_16[4] = __pyx_mstate_global->__pyx_kp_u_vs;
      __pyx_t_16[5] = __pyx_t_15;
      __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_16, 6, 31 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_12) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14) + 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_12) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_14) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15));
      if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_8 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_17};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1066, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+1067:                 return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      goto __pyx_L0;

 1068: 

 1069:         # Compare bullets

+1070:         if len(self.bullets) != len(other.bullets):

  __pyx_t_3 = __pyx_v_self->bullets;
  __Pyx_INCREF(__pyx_t_3);
  if (unlikely(__pyx_t_3 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 1070, __pyx_L1_error)
  }
  __pyx_t_5 = __Pyx_PyList_GET_SIZE(__pyx_t_3); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1070, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1070, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1070, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_2 = (__pyx_t_5 != __pyx_t_4);
  if (__pyx_t_2) {
/* … */
  }

+1071:             print("Bullet lists are different lengths!")

    __pyx_t_9 = NULL;
    __Pyx_INCREF(__pyx_builtin_print);
    __pyx_t_7 = __pyx_builtin_print; 
    __pyx_t_8 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_Bullet_lists_are_different_lengt};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1071, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1072:             return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

+1073:         for i, (bul_a, bul_b) in enumerate(zip(self.bullets, other.bullets)):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_3 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_9 = NULL;
  __Pyx_INCREF(__pyx_builtin_zip);
  __pyx_t_10 = __pyx_builtin_zip; 
  __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_8 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_v_self->bullets, __pyx_t_17};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1073, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }
  if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
    __pyx_t_10 = __pyx_t_7; __Pyx_INCREF(__pyx_t_10);
    __pyx_t_4 = 0;
    __pyx_t_11 = NULL;
  } else {
    __pyx_t_4 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1073, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1073, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  for (;;) {
    if (likely(!__pyx_t_11)) {
      if (likely(PyList_CheckExact(__pyx_t_10))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1073, __pyx_L1_error)
          #endif
          if (__pyx_t_4 >= __pyx_temp) break;
        }
        __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_4);
        ++__pyx_t_4;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1073, __pyx_L1_error)
          #endif
          if (__pyx_t_4 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_4));
        #else
        __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_4);
        #endif
        ++__pyx_t_4;
      }
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1073, __pyx_L1_error)
    } else {
      __pyx_t_7 = __pyx_t_11(__pyx_t_10);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1073, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_7);
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 1073, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_17 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_17);
        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_9);
      } else {
        __pyx_t_17 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1073, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_17);
        __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1073, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_9);
      }
      #else
      __pyx_t_17 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1073, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1073, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1073, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6);
      index = 0; __pyx_t_17 = __pyx_t_13(__pyx_t_6); if (unlikely(!__pyx_t_17)) goto __pyx_L14_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_17);
      index = 1; __pyx_t_9 = __pyx_t_13(__pyx_t_6); if (unlikely(!__pyx_t_9)) goto __pyx_L14_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_9);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_13(__pyx_t_6), 2) < 0) __PYX_ERR(0, 1073, __pyx_L1_error)
      __pyx_t_13 = NULL;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      goto __pyx_L15_unpacking_done;
      __pyx_L14_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_13 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 1073, __pyx_L1_error)
      __pyx_L15_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_bul_a, __pyx_t_17);
    __pyx_t_17 = 0;
    __Pyx_XDECREF_SET(__pyx_v_bul_b, __pyx_t_9);
    __pyx_t_9 = 0;
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
    __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1073, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3);
    __pyx_t_3 = __pyx_t_7;
    __pyx_t_7 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1074:             if bul_a != bul_b:

    __pyx_t_7 = PyObject_RichCompare(__pyx_v_bul_a, __pyx_v_bul_b, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1074, __pyx_L1_error)
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1074, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_2) {
/* … */
    }

+1075:                 print(f"Bullets don't match at index {i}: {bul_a} vs {bul_b}")

      __pyx_t_9 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_17 = __pyx_builtin_print; 
      __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1075, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_bul_a, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1075, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_14 = __Pyx_PyObject_FormatSimple(__pyx_v_bul_b, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1075, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_16[0] = __pyx_mstate_global->__pyx_kp_u_Bullets_don_t_match_at_index;
      __pyx_t_16[1] = __pyx_t_6;
      __pyx_t_16[2] = __pyx_mstate_global->__pyx_kp_u__10;
      __pyx_t_16[3] = __pyx_t_15;
      __pyx_t_16[4] = __pyx_mstate_global->__pyx_kp_u_vs;
      __pyx_t_16[5] = __pyx_t_14;
      __pyx_t_12 = __Pyx_PyUnicode_Join(__pyx_t_16, 6, 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_14));
      if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1075, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_8 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_12};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1075, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+1076:                 return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      goto __pyx_L0;

 1077: 

 1078:         # Compare mines

+1079:         if len(self.mines) != len(other.mines):

  __pyx_t_3 = __pyx_v_self->mines;
  __Pyx_INCREF(__pyx_t_3);
  if (unlikely(__pyx_t_3 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 1079, __pyx_L1_error)
  }
  __pyx_t_4 = __Pyx_PyList_GET_SIZE(__pyx_t_3); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1079, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_2 = (__pyx_t_4 != __pyx_t_5);
  if (__pyx_t_2) {
/* … */
  }

+1080:             print("Mine lists are different lengths!")

    __pyx_t_10 = NULL;
    __Pyx_INCREF(__pyx_builtin_print);
    __pyx_t_7 = __pyx_builtin_print; 
    __pyx_t_8 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_Mine_lists_are_different_lengths};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1080, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1081:             return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

+1082:         for i, (mine_a, mine_b) in enumerate(zip(self.mines, other.mines)):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_3 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_10 = NULL;
  __Pyx_INCREF(__pyx_builtin_zip);
  __pyx_t_17 = __pyx_builtin_zip; 
  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1082, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_8 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_v_self->mines, __pyx_t_12};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1082, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }
  if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
    __pyx_t_17 = __pyx_t_7; __Pyx_INCREF(__pyx_t_17);
    __pyx_t_5 = 0;
    __pyx_t_11 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_17 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1082, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_17); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1082, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  for (;;) {
    if (likely(!__pyx_t_11)) {
      if (likely(PyList_CheckExact(__pyx_t_17))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_17);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1082, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_17, __pyx_t_5);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_17);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1082, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_17, __pyx_t_5));
        #else
        __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_17, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1082, __pyx_L1_error)
    } else {
      __pyx_t_7 = __pyx_t_11(__pyx_t_17);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1082, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_7);
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 1082, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_12 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_12);
        __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_10);
      } else {
        __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1082, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_12);
        __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1082, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_10);
      }
      #else
      __pyx_t_12 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1082, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1082, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_9 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1082, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9);
      index = 0; __pyx_t_12 = __pyx_t_13(__pyx_t_9); if (unlikely(!__pyx_t_12)) goto __pyx_L21_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_12);
      index = 1; __pyx_t_10 = __pyx_t_13(__pyx_t_9); if (unlikely(!__pyx_t_10)) goto __pyx_L21_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_10);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_13(__pyx_t_9), 2) < 0) __PYX_ERR(0, 1082, __pyx_L1_error)
      __pyx_t_13 = NULL;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      goto __pyx_L22_unpacking_done;
      __pyx_L21_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_13 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 1082, __pyx_L1_error)
      __pyx_L22_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_mine_a, __pyx_t_12);
    __pyx_t_12 = 0;
    __Pyx_XDECREF_SET(__pyx_v_mine_b, __pyx_t_10);
    __pyx_t_10 = 0;
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
    __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1082, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3);
    __pyx_t_3 = __pyx_t_7;
    __pyx_t_7 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1083:             if mine_a != mine_b:

    __pyx_t_7 = PyObject_RichCompare(__pyx_v_mine_a, __pyx_v_mine_b, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1083, __pyx_L1_error)
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1083, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_2) {
/* … */
    }

+1084:                 print(f"Mines don't match at index {i}: {mine_a} vs {mine_b}")

      __pyx_t_10 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_12 = __pyx_builtin_print; 
      __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1084, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_14 = __Pyx_PyObject_FormatSimple(__pyx_v_mine_a, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1084, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_mine_b, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1084, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_16[0] = __pyx_mstate_global->__pyx_kp_u_Mines_don_t_match_at_index;
      __pyx_t_16[1] = __pyx_t_9;
      __pyx_t_16[2] = __pyx_mstate_global->__pyx_kp_u__10;
      __pyx_t_16[3] = __pyx_t_14;
      __pyx_t_16[4] = __pyx_mstate_global->__pyx_kp_u_vs;
      __pyx_t_16[5] = __pyx_t_15;
      __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_16, 6, 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14) + 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_14) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15));
      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1084, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_8 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_6};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1084, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+1085:                 return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      goto __pyx_L0;

 1086: 

 1087:         '''

 1088:         # Compare ships

 1089:         if len(self.ships) != len(other.ships):

 1090:             print("Ships lists are different lengths!")

 1091:             return False

 1092:         for i, (ship_a, ship_b) in enumerate(zip(self.ships, other.ships)):

 1093:             if ship_a != ship_b:

 1094:                 print(f"Ships don't match at index {i}: {ship_a} vs {ship_b}")

 1095:                 return False

 1096:         '''

 1097:         # Trivial properties like timesteps are not compared, assuming they don't affect game state equality

+1098:         return True

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_True);
  __pyx_r = Py_True;
  goto __pyx_L0;

 1099: 

 1100: '''

 1101: class Target:

 1102:     __slots__ = ('asteroid', 'feasible', 'shooting_angle_error_deg', 'aiming_timesteps_required', 'interception_time_s', 'intercept_x', 'intercept_y', 'asteroid_dist_during_interception', 'imminent_collision_time_s', 'asteroid_will_get_hit_by_my_mine', 'asteroid_will_get_hit_by_their_mine')

 1103: 

 1104:     def __init__(self, asteroid: Asteroid, feasible: bool = False, shooting_angle_error_deg: float = 0.0, aiming_timesteps_required: int = 0, interception_time_s: float = 0.0, intercept_x: float = 0.0, intercept_y: float = 0.0, asteroid_dist_during_interception: float = 0.0, imminent_collision_time_s: float = 0.0, asteroid_will_get_hit_by_my_mine: bool = False, asteroid_will_get_hit_by_their_mine: bool = False) -> None:

 1105:         self.asteroid = asteroid

 1106:         self.feasible = feasible

 1107:         self.shooting_angle_error_deg = shooting_angle_error_deg

 1108:         self.aiming_timesteps_required = aiming_timesteps_required

 1109:         self.interception_time_s = interception_time_s

 1110:         self.intercept_x = intercept_x

 1111:         self.intercept_y = intercept_y

 1112:         self.asteroid_dist_during_interception = asteroid_dist_during_interception

 1113:         self.imminent_collision_time_s = imminent_collision_time_s

 1114:         self.asteroid_will_get_hit_by_my_mine = asteroid_will_get_hit_by_my_mine

 1115:         self.asteroid_will_get_hit_by_their_mine = asteroid_will_get_hit_by_their_mine

 1116: 

 1117:     def __str__(self) -> str:

 1118:         return f'Target(asteroid={self.asteroid}, feasible={self.feasible}, shooting_angle_error_deg={self.shooting_angle_error_deg}, aiming_timesteps_required={self.aiming_timesteps_required}, interception_time_s={self.interception_time_s}, intercept_x={self.intercept_x}, intercept_y={self.intercept_y}, asteroid_dist_during_interception={self.asteroid_dist_during_interception}, imminent_collision_time_s={self.imminent_collision_time_s}, asteroid_will_get_hit_by_my_mine={self.asteroid_will_get_hit_by_my_mine}, asteroid_will_get_hit_by_their_mine={self.asteroid_will_get_hit_by_their_mine})'

 1119: 

 1120:     def __repr__(self) -> str:

 1121:         return self.__str__()

 1122: 

 1123:     def copy(self) -> 'Target':

 1124:         return Target(

 1125:             asteroid=self.asteroid.copy(), 

 1126:             feasible=self.feasible, 

 1127:             shooting_angle_error_deg=self.shooting_angle_error_deg, 

 1128:             aiming_timesteps_required=self.aiming_timesteps_required, 

 1129:             interception_time_s=self.interception_time_s, 

 1130:             intercept_x=self.intercept_x, 

 1131:             intercept_y=self.intercept_y, 

 1132:             asteroid_dist_during_interception=self.asteroid_dist_during_interception, 

 1133:             imminent_collision_time_s=self.imminent_collision_time_s, 

 1134:             asteroid_will_get_hit_by_my_mine=self.asteroid_will_get_hit_by_my_mine,

 1135:             asteroid_will_get_hit_by_their_mine=self.asteroid_will_get_hit_by_their_mine

 1136:         )

 1137: '''

 1138: 

+1139: cdef class Target:

struct __pyx_obj_14neo_controller_Target {
  PyObject_HEAD
  struct __pyx_obj_14neo_controller_Asteroid *asteroid;
  int feasible;
  double shooting_angle_error_deg;
  int aiming_timesteps_required;
  double interception_time_s;
  double intercept_x;
  double intercept_y;
  double asteroid_dist_during_interception;
  double imminent_collision_time_s;
  int asteroid_will_get_hit_by_my_mine;
  int asteroid_will_get_hit_by_their_mine;
};

+1140:     cdef public Asteroid asteroid

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_8asteroid_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_8asteroid_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_8asteroid___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_8asteroid___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_self->asteroid);
  __pyx_r = ((PyObject *)__pyx_v_self->asteroid);
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_8asteroid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_8asteroid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_8asteroid_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_8asteroid_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid))))) __PYX_ERR(0, 1140, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->asteroid);
  __Pyx_DECREF((PyObject *)__pyx_v_self->asteroid);
  __pyx_v_self->asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.asteroid.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_8asteroid_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_6Target_8asteroid_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_8asteroid_4__del__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_8asteroid_4__del__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->asteroid);
  __Pyx_DECREF((PyObject *)__pyx_v_self->asteroid);
  __pyx_v_self->asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1141:     cdef public bint feasible

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_8feasible_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_8feasible_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_8feasible___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_8feasible___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->feasible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.feasible.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_8feasible_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_8feasible_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_8feasible_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_8feasible_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1141, __pyx_L1_error)
  __pyx_v_self->feasible = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.feasible.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1142:     cdef public double shooting_angle_error_deg

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_24shooting_angle_error_deg_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_24shooting_angle_error_deg_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_24shooting_angle_error_deg___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_24shooting_angle_error_deg___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->shooting_angle_error_deg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.shooting_angle_error_deg.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_24shooting_angle_error_deg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_24shooting_angle_error_deg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_24shooting_angle_error_deg_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_24shooting_angle_error_deg_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1142, __pyx_L1_error)
  __pyx_v_self->shooting_angle_error_deg = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.shooting_angle_error_deg.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1143:     cdef public int aiming_timesteps_required

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_25aiming_timesteps_required_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_25aiming_timesteps_required_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_25aiming_timesteps_required___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_25aiming_timesteps_required___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->aiming_timesteps_required); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1143, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.aiming_timesteps_required.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_25aiming_timesteps_required_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_25aiming_timesteps_required_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_25aiming_timesteps_required_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_25aiming_timesteps_required_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1143, __pyx_L1_error)
  __pyx_v_self->aiming_timesteps_required = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.aiming_timesteps_required.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1144:     cdef public double interception_time_s

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_19interception_time_s_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_19interception_time_s_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_19interception_time_s___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_19interception_time_s___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->interception_time_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1144, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.interception_time_s.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_19interception_time_s_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_19interception_time_s_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_19interception_time_s_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_19interception_time_s_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1144, __pyx_L1_error)
  __pyx_v_self->interception_time_s = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.interception_time_s.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1145:     cdef public double intercept_x

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_11intercept_x_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_11intercept_x_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_11intercept_x___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_11intercept_x___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->intercept_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.intercept_x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_11intercept_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_11intercept_x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_11intercept_x_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_11intercept_x_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1145, __pyx_L1_error)
  __pyx_v_self->intercept_x = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.intercept_x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1146:     cdef public double intercept_y

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_11intercept_y_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_11intercept_y_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_11intercept_y___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_11intercept_y___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->intercept_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.intercept_y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_11intercept_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_11intercept_y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_11intercept_y_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_11intercept_y_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1146, __pyx_L1_error)
  __pyx_v_self->intercept_y = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.intercept_y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1147:     cdef public double asteroid_dist_during_interception

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_33asteroid_dist_during_interception_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_33asteroid_dist_during_interception_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_33asteroid_dist_during_interception___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_33asteroid_dist_during_interception___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->asteroid_dist_during_interception); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.asteroid_dist_during_interception.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_33asteroid_dist_during_interception_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_33asteroid_dist_during_interception_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_33asteroid_dist_during_interception_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_33asteroid_dist_during_interception_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1147, __pyx_L1_error)
  __pyx_v_self->asteroid_dist_during_interception = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.asteroid_dist_during_interception.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1148:     cdef public double imminent_collision_time_s

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_25imminent_collision_time_s_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_25imminent_collision_time_s_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_25imminent_collision_time_s___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_25imminent_collision_time_s___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->imminent_collision_time_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.imminent_collision_time_s.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_25imminent_collision_time_s_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_25imminent_collision_time_s_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_25imminent_collision_time_s_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_25imminent_collision_time_s_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1148, __pyx_L1_error)
  __pyx_v_self->imminent_collision_time_s = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.imminent_collision_time_s.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1149:     cdef public bint asteroid_will_get_hit_by_my_mine

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1149, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.asteroid_will_get_hit_by_my_mine.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_32asteroid_will_get_hit_by_my_mine_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1149, __pyx_L1_error)
  __pyx_v_self->asteroid_will_get_hit_by_my_mine = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.asteroid_will_get_hit_by_my_mine.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1150:     cdef public bint asteroid_will_get_hit_by_their_mine

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine___get__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine___get__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->asteroid_will_get_hit_by_their_mine); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Target.asteroid_will_get_hit_by_their_mine.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine_2__set__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target_35asteroid_will_get_hit_by_their_mine_2__set__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1150, __pyx_L1_error)
  __pyx_v_self->asteroid_will_get_hit_by_their_mine = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Target.asteroid_will_get_hit_by_their_mine.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 1151: 

+1152:     def __cinit__(self,

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Target_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_6Target_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  int __pyx_v_feasible;
  double __pyx_v_shooting_angle_error_deg;
  int __pyx_v_aiming_timesteps_required;
  double __pyx_v_interception_time_s;
  double __pyx_v_intercept_x;
  double __pyx_v_intercept_y;
  double __pyx_v_asteroid_dist_during_interception;
  double __pyx_v_imminent_collision_time_s;
  int __pyx_v_asteroid_will_get_hit_by_my_mine;
  int __pyx_v_asteroid_will_get_hit_by_their_mine;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_feasible,&__pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg,&__pyx_mstate_global->__pyx_n_u_aiming_timesteps_required,&__pyx_mstate_global->__pyx_n_u_interception_time_s,&__pyx_mstate_global->__pyx_n_u_intercept_x,&__pyx_mstate_global->__pyx_n_u_intercept_y,&__pyx_mstate_global->__pyx_n_u_asteroid_dist_during_interceptio,&__pyx_mstate_global->__pyx_n_u_imminent_collision_time_s,&__pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_my_mine,&__pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_their_m,0};
  PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1152, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case 11:
        values[10] = __Pyx_ArgRef_VARARGS(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_VARARGS(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_VARARGS(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_VARARGS(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 1152, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 11, i); __PYX_ERR(0, 1152, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case 11:
        values[10] = __Pyx_ArgRef_VARARGS(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_VARARGS(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_VARARGS(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_VARARGS(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_VARARGS(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_VARARGS(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1152, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1152, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    if (values[1]) {
      __pyx_v_feasible = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_feasible == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1154, __pyx_L3_error)
    } else {
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Target___cinit__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, int __pyx_v_feasible, double __pyx_v_shooting_angle_error_deg, int __pyx_v_aiming_timesteps_required, double __pyx_v_interception_time_s, double __pyx_v_intercept_x, double __pyx_v_intercept_y, double __pyx_v_asteroid_dist_during_interception, double __pyx_v_imminent_collision_time_s, int __pyx_v_asteroid_will_get_hit_by_my_mine, int __pyx_v_asteroid_will_get_hit_by_their_mine) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1153:                   Asteroid asteroid,

+1154:                   bint feasible=False,

      __pyx_v_feasible = ((int)0);
    }
    if (values[2]) {
      __pyx_v_shooting_angle_error_deg = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_shooting_angle_error_deg == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1155, __pyx_L3_error)
    } else {
      __pyx_v_shooting_angle_error_deg = ((double)0.0);
    }
    if (values[3]) {
      __pyx_v_aiming_timesteps_required = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_aiming_timesteps_required == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1156, __pyx_L3_error)
    } else {
      __pyx_v_aiming_timesteps_required = ((int)0);
    }
    if (values[4]) {
      __pyx_v_interception_time_s = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_interception_time_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1157, __pyx_L3_error)
    } else {
      __pyx_v_interception_time_s = ((double)0.0);
    }
    if (values[5]) {
      __pyx_v_intercept_x = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_intercept_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1158, __pyx_L3_error)
    } else {
      __pyx_v_intercept_x = ((double)0.0);
    }
    if (values[6]) {
      __pyx_v_intercept_y = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_intercept_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1159, __pyx_L3_error)
    } else {
      __pyx_v_intercept_y = ((double)0.0);
    }
    if (values[7]) {
      __pyx_v_asteroid_dist_during_interception = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_asteroid_dist_during_interception == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1160, __pyx_L3_error)
    } else {
      __pyx_v_asteroid_dist_during_interception = ((double)0.0);
    }
    if (values[8]) {
      __pyx_v_imminent_collision_time_s = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_imminent_collision_time_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1161, __pyx_L3_error)
    } else {
      __pyx_v_imminent_collision_time_s = ((double)0.0);
    }
    if (values[9]) {
      __pyx_v_asteroid_will_get_hit_by_my_mine = __Pyx_PyObject_IsTrue(values[9]); if (unlikely((__pyx_v_asteroid_will_get_hit_by_my_mine == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1162, __pyx_L3_error)
    } else {

 1155:                   double shooting_angle_error_deg=0.0,

 1156:                   int aiming_timesteps_required=0,

 1157:                   double interception_time_s=0.0,

 1158:                   double intercept_x=0.0,

 1159:                   double intercept_y=0.0,

 1160:                   double asteroid_dist_during_interception=0.0,

 1161:                   double imminent_collision_time_s=0.0,

+1162:                   bint asteroid_will_get_hit_by_my_mine=False,

      __pyx_v_asteroid_will_get_hit_by_my_mine = ((int)0);
    }
    if (values[10]) {
      __pyx_v_asteroid_will_get_hit_by_their_mine = __Pyx_PyObject_IsTrue(values[10]); if (unlikely((__pyx_v_asteroid_will_get_hit_by_their_mine == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1163, __pyx_L3_error)
    } else {

+1163:                   bint asteroid_will_get_hit_by_their_mine=False):

      __pyx_v_asteroid_will_get_hit_by_their_mine = ((int)0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 11, __pyx_nargs); __PYX_ERR(0, 1152, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Target.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 1, "asteroid", 0))) __PYX_ERR(0, 1153, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Target___cinit__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self), __pyx_v_asteroid, __pyx_v_feasible, __pyx_v_shooting_angle_error_deg, __pyx_v_aiming_timesteps_required, __pyx_v_interception_time_s, __pyx_v_intercept_x, __pyx_v_intercept_y, __pyx_v_asteroid_dist_during_interception, __pyx_v_imminent_collision_time_s, __pyx_v_asteroid_will_get_hit_by_my_mine, __pyx_v_asteroid_will_get_hit_by_their_mine);

+1164:         self.asteroid = asteroid

  __Pyx_INCREF((PyObject *)__pyx_v_asteroid);
  __Pyx_GIVEREF((PyObject *)__pyx_v_asteroid);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->asteroid);
  __Pyx_DECREF((PyObject *)__pyx_v_self->asteroid);
  __pyx_v_self->asteroid = __pyx_v_asteroid;

+1165:         self.feasible = feasible

  __pyx_v_self->feasible = __pyx_v_feasible;

+1166:         self.shooting_angle_error_deg = shooting_angle_error_deg

  __pyx_v_self->shooting_angle_error_deg = __pyx_v_shooting_angle_error_deg;

+1167:         self.aiming_timesteps_required = aiming_timesteps_required

  __pyx_v_self->aiming_timesteps_required = __pyx_v_aiming_timesteps_required;

+1168:         self.interception_time_s = interception_time_s

  __pyx_v_self->interception_time_s = __pyx_v_interception_time_s;

+1169:         self.intercept_x = intercept_x

  __pyx_v_self->intercept_x = __pyx_v_intercept_x;

+1170:         self.intercept_y = intercept_y

  __pyx_v_self->intercept_y = __pyx_v_intercept_y;

+1171:         self.asteroid_dist_during_interception = asteroid_dist_during_interception

  __pyx_v_self->asteroid_dist_during_interception = __pyx_v_asteroid_dist_during_interception;

+1172:         self.imminent_collision_time_s = imminent_collision_time_s

  __pyx_v_self->imminent_collision_time_s = __pyx_v_imminent_collision_time_s;

+1173:         self.asteroid_will_get_hit_by_my_mine = asteroid_will_get_hit_by_my_mine

  __pyx_v_self->asteroid_will_get_hit_by_my_mine = __pyx_v_asteroid_will_get_hit_by_my_mine;

+1174:         self.asteroid_will_get_hit_by_their_mine = asteroid_will_get_hit_by_their_mine

  __pyx_v_self->asteroid_will_get_hit_by_their_mine = __pyx_v_asteroid_will_get_hit_by_their_mine;

 1175: 

+1176:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_2__str__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_2__str__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("neo_controller.Target.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1177:         return ("Target(asteroid=%s, feasible=%s, shooting_angle_error_deg=%f, aiming_timesteps_required=%d, "

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_13 = __Pyx_PyUnicode_Join(__pyx_t_12, 23, 16 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 28 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 22 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 14 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 36 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 35 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 38 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_11) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
  if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __pyx_r = __pyx_t_13;
  __pyx_t_13 = 0;
  goto __pyx_L0;

 1178:                 "interception_time_s=%f, intercept_x=%f, intercept_y=%f, asteroid_dist_during_interception=%f, "

 1179:                 "imminent_collision_time_s=%f, asteroid_will_get_hit_by_my_mine=%s, asteroid_will_get_hit_by_their_mine=%s)" %

+1180:                 (str(self.asteroid), self.feasible, self.shooting_angle_error_deg, self.aiming_timesteps_required,

  __pyx_t_1 = __Pyx_PyObject_Unicode(((PyObject *)__pyx_v_self->asteroid)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->feasible); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_self->shooting_angle_error_deg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_Format(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyUnicode_From_int(__pyx_v_self->aiming_timesteps_required, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);

+1181:                  self.interception_time_s, self.intercept_x, self.intercept_y, self.asteroid_dist_during_interception,

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->interception_time_s); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->intercept_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->intercept_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->asteroid_dist_during_interception); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1182:                  self.imminent_collision_time_s, self.asteroid_will_get_hit_by_my_mine, self.asteroid_will_get_hit_by_their_mine))

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->imminent_collision_time_s); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_10 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_11 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->asteroid_will_get_hit_by_their_mine); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_12[0] = __pyx_mstate_global->__pyx_kp_u_Target_asteroid;
  __pyx_t_12[1] = __pyx_t_1;
  __pyx_t_12[2] = __pyx_mstate_global->__pyx_kp_u_feasible_2;
  __pyx_t_12[3] = __pyx_t_2;
  __pyx_t_12[4] = __pyx_mstate_global->__pyx_kp_u_shooting_angle_error_deg_2;
  __pyx_t_12[5] = __pyx_t_4;
  __pyx_t_12[6] = __pyx_mstate_global->__pyx_kp_u_aiming_timesteps_required_2;
  __pyx_t_12[7] = __pyx_t_3;
  __pyx_t_12[8] = __pyx_mstate_global->__pyx_kp_u_interception_time_s_2;
  __pyx_t_12[9] = __pyx_t_6;
  __pyx_t_12[10] = __pyx_mstate_global->__pyx_kp_u_intercept_x_2;
  __pyx_t_12[11] = __pyx_t_7;
  __pyx_t_12[12] = __pyx_mstate_global->__pyx_kp_u_intercept_y_2;
  __pyx_t_12[13] = __pyx_t_8;
  __pyx_t_12[14] = __pyx_mstate_global->__pyx_kp_u_asteroid_dist_during_intercepti;
  __pyx_t_12[15] = __pyx_t_9;
  __pyx_t_12[16] = __pyx_mstate_global->__pyx_kp_u_imminent_collision_time_s_2;
  __pyx_t_12[17] = __pyx_t_10;
  __pyx_t_12[18] = __pyx_mstate_global->__pyx_kp_u_asteroid_will_get_hit_by_my_min;
  __pyx_t_12[19] = __pyx_t_5;
  __pyx_t_12[20] = __pyx_mstate_global->__pyx_kp_u_asteroid_will_get_hit_by_their;
  __pyx_t_12[21] = __pyx_t_11;
  __pyx_t_12[22] = __pyx_mstate_global->__pyx_kp_u__2;

 1183: 

+1184:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Target_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Target_4__repr__(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_4__repr__(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Target.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1185:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1185, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1186: 

+1187:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Target_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Target_7copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Target_7copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Target_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_6Target_6copy(((struct __pyx_obj_14neo_controller_Target *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Target_6copy(struct __pyx_obj_14neo_controller_Target *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_AddTraceback("neo_controller.Target.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Target_7copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Target_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[61])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1187, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Target, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < 0) __PYX_ERR(0, 1187, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1188:         return Target(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Target);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Target); 

+1189:             asteroid=self.asteroid.copy(),

  __pyx_t_5 = ((PyObject *)__pyx_v_self->asteroid);
  __Pyx_INCREF(__pyx_t_5);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }

+1190:             feasible=self.feasible,

  __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_self->feasible); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+1191:             shooting_angle_error_deg=self.shooting_angle_error_deg,

  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_self->shooting_angle_error_deg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);

+1192:             aiming_timesteps_required=self.aiming_timesteps_required,

  __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_self->aiming_timesteps_required); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);

+1193:             interception_time_s=self.interception_time_s,

  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_self->interception_time_s); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);

+1194:             intercept_x=self.intercept_x,

  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_self->intercept_x); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1194, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);

+1195:             intercept_y=self.intercept_y,

  __pyx_t_11 = PyFloat_FromDouble(__pyx_v_self->intercept_y); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);

+1196:             asteroid_dist_during_interception=self.asteroid_dist_during_interception,

  __pyx_t_12 = PyFloat_FromDouble(__pyx_v_self->asteroid_dist_during_interception); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1196, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);

+1197:             imminent_collision_time_s=self.imminent_collision_time_s,

  __pyx_t_13 = PyFloat_FromDouble(__pyx_v_self->imminent_collision_time_s); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);

+1198:             asteroid_will_get_hit_by_my_mine=self.asteroid_will_get_hit_by_my_mine,

  __pyx_t_14 = __Pyx_PyBool_FromLong(__pyx_v_self->asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1198, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);

+1199:             asteroid_will_get_hit_by_their_mine=self.asteroid_will_get_hit_by_their_mine

  __pyx_t_15 = __Pyx_PyBool_FromLong(__pyx_v_self->asteroid_will_get_hit_by_their_mine); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 11 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_16 = __Pyx_MakeVectorcallBuilderKwds(11); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1188, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid, __pyx_t_4, __pyx_t_16, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_feasible, __pyx_t_5, __pyx_t_16, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg, __pyx_t_7, __pyx_t_16, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_aiming_timesteps_required, __pyx_t_8, __pyx_t_16, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_interception_time_s, __pyx_t_9, __pyx_t_16, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_intercept_x, __pyx_t_10, __pyx_t_16, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_intercept_y, __pyx_t_11, __pyx_t_16, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid_dist_during_interceptio, __pyx_t_12, __pyx_t_16, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_imminent_collision_time_s, __pyx_t_13, __pyx_t_16, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_my_mine, __pyx_t_14, __pyx_t_16, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_their_m, __pyx_t_15, __pyx_t_16, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 1188, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_16);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1188, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1200:         )

 1201: 

 1202: '''

 1203: class Action:

 1204:     __slots__ = ('thrust', 'turn_rate', 'fire', 'drop_mine', 'timestep')

 1205: 

 1206:     def __init__(self, thrust: float = 0.0, turn_rate: float = 0.0, fire: bool = False, drop_mine: bool = False, timestep: int = 0) -> None:

 1207:         self.thrust = thrust

 1208:         self.turn_rate = turn_rate

 1209:         self.fire = fire

 1210:         self.drop_mine = drop_mine

 1211:         self.timestep = timestep

 1212: 

 1213:     def __str__(self) -> str:

 1214:         return f'Action(thrust={self.thrust}, turn_rate={self.turn_rate}, fire={self.fire}, drop_mine={self.drop_mine}, timestep={self.timestep})'

 1215: 

 1216:     def __repr__(self) -> str:

 1217:         return self.__str__()

 1218: 

 1219:     def copy(self) -> 'Action':

 1220:         return Action(

 1221:             thrust=self.thrust, 

 1222:             turn_rate=self.turn_rate, 

 1223:             fire=self.fire, 

 1224:             drop_mine=self.drop_mine, 

 1225:             timestep=self.timestep

 1226:         )

 1227: '''

 1228: 

+1229: cdef class Action:

struct __pyx_obj_14neo_controller_Action {
  PyObject_HEAD
  double thrust;
  double turn_rate;
  int fire;
  int drop_mine;
  int timestep;
};

+1230:     cdef public double thrust

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_6thrust_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Action_6thrust_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_6thrust___get__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_6thrust___get__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->thrust); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Action.thrust.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Action_6thrust_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Action_6thrust_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_6thrust_2__set__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Action_6thrust_2__set__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1230, __pyx_L1_error)
  __pyx_v_self->thrust = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Action.thrust.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1231:     cdef public double turn_rate

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_9turn_rate_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Action_9turn_rate_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_9turn_rate___get__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_9turn_rate___get__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->turn_rate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Action.turn_rate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Action_9turn_rate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Action_9turn_rate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_9turn_rate_2__set__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Action_9turn_rate_2__set__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1231, __pyx_L1_error)
  __pyx_v_self->turn_rate = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Action.turn_rate.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1232:     cdef public bint fire

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_4fire_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Action_4fire_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_4fire___get__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_4fire___get__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->fire); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Action.fire.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Action_4fire_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Action_4fire_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_4fire_2__set__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Action_4fire_2__set__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1232, __pyx_L1_error)
  __pyx_v_self->fire = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Action.fire.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1233:     cdef public bint drop_mine

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_9drop_mine_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Action_9drop_mine_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_9drop_mine___get__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_9drop_mine___get__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->drop_mine); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Action.drop_mine.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Action_9drop_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Action_9drop_mine_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_9drop_mine_2__set__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Action_9drop_mine_2__set__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1233, __pyx_L1_error)
  __pyx_v_self->drop_mine = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Action.drop_mine.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1234:     cdef public int timestep

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_8timestep_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Action_8timestep_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_8timestep___get__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_8timestep___get__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Action.timestep.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Action_8timestep_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_6Action_8timestep_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_8timestep_2__set__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Action_8timestep_2__set__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1234, __pyx_L1_error)
  __pyx_v_self->timestep = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Action.timestep.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 1235: 

+1236:     def __cinit__(self,

/* Python wrapper */
static int __pyx_pw_14neo_controller_6Action_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_6Action_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  double __pyx_v_thrust;
  double __pyx_v_turn_rate;
  int __pyx_v_fire;
  int __pyx_v_drop_mine;
  int __pyx_v_timestep;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_thrust,&__pyx_mstate_global->__pyx_n_u_turn_rate,&__pyx_mstate_global->__pyx_n_u_fire,&__pyx_mstate_global->__pyx_n_u_drop_mine,&__pyx_mstate_global->__pyx_n_u_timestep,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1236, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 1236, __pyx_L3_error)
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1236, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    if (values[0]) {
      __pyx_v_thrust = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_thrust == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1237, __pyx_L3_error)
    } else {
      __pyx_v_thrust = ((double)0.0);
    }
    if (values[1]) {
      __pyx_v_turn_rate = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1238, __pyx_L3_error)
    } else {
      __pyx_v_turn_rate = ((double)0.0);
    }
    if (values[2]) {
      __pyx_v_fire = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_fire == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1239, __pyx_L3_error)
    } else {
/* … */
  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_6Action___cinit__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self, double __pyx_v_thrust, double __pyx_v_turn_rate, int __pyx_v_fire, int __pyx_v_drop_mine, int __pyx_v_timestep) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  return __pyx_r;
}

 1237:                   double thrust=0.0,

 1238:                   double turn_rate=0.0,

+1239:                   bint fire=False,

      __pyx_v_fire = ((int)0);
    }
    if (values[3]) {
      __pyx_v_drop_mine = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_drop_mine == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1240, __pyx_L3_error)
    } else {

+1240:                   bint drop_mine=False,

      __pyx_v_drop_mine = ((int)0);
    }
    if (values[4]) {
      __pyx_v_timestep = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timestep == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1241, __pyx_L3_error)
    } else {
      __pyx_v_timestep = ((int)0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 5, __pyx_nargs); __PYX_ERR(0, 1236, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Action.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Action___cinit__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self), __pyx_v_thrust, __pyx_v_turn_rate, __pyx_v_fire, __pyx_v_drop_mine, __pyx_v_timestep);

 1241:                   int timestep=0):

+1242:         self.thrust = thrust

  __pyx_v_self->thrust = __pyx_v_thrust;

+1243:         self.turn_rate = turn_rate

  __pyx_v_self->turn_rate = __pyx_v_turn_rate;

+1244:         self.fire = fire

  __pyx_v_self->fire = __pyx_v_fire;

+1245:         self.drop_mine = drop_mine

  __pyx_v_self->drop_mine = __pyx_v_drop_mine;

+1246:         self.timestep = timestep

  __pyx_v_self->timestep = __pyx_v_timestep;

 1247: 

+1248:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Action_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_2__str__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_2__str__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.Action.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1249:         return (

  __Pyx_XDECREF(__pyx_r);

+1250:             "Action(thrust=%f, turn_rate=%f, fire=%s, drop_mine=%s, timestep=%d)"

  __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 11, 14 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 12 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 7 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3));
  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

+1251:             % (self.thrust, self.turn_rate, self.fire, self.drop_mine, self.timestep)

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->thrust); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->turn_rate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->fire); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_self->drop_mine); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyUnicode_From_int(__pyx_v_self->timestep, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_Action_thrust;
  __pyx_t_6[1] = __pyx_t_2;
  __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u_turn_rate_2;
  __pyx_t_6[3] = __pyx_t_3;
  __pyx_t_6[4] = __pyx_mstate_global->__pyx_kp_u_fire_2;
  __pyx_t_6[5] = __pyx_t_1;
  __pyx_t_6[6] = __pyx_mstate_global->__pyx_kp_u_drop_mine_2;
  __pyx_t_6[7] = __pyx_t_4;
  __pyx_t_6[8] = __pyx_mstate_global->__pyx_kp_u_timestep_2;
  __pyx_t_6[9] = __pyx_t_5;
  __pyx_t_6[10] = __pyx_mstate_global->__pyx_kp_u__2;

 1252:         )

 1253: 

+1254:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_6Action_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Action_4__repr__(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_4__repr__(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Action.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1255:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1255, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1256: 

+1257:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Action_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Action_7copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Action_7copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Action_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_6Action_6copy(((struct __pyx_obj_14neo_controller_Action *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Action_6copy(struct __pyx_obj_14neo_controller_Action *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Action.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Action_7copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Action_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[64])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1257, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_Action, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < 0) __PYX_ERR(0, 1257, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1258:         return Action(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 

+1259:             thrust=self.thrust,

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->thrust); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1259, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+1260:             turn_rate=self.turn_rate,

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->turn_rate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+1261:             fire=self.fire,

  __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_v_self->fire); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1261, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);

+1262:             drop_mine=self.drop_mine,

  __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->drop_mine); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1262, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);

+1263:             timestep=self.timestep

  __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_self->timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1263, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1258, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_t_4, __pyx_t_10, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1258, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_t_5, __pyx_t_10, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 1258, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, __pyx_t_6, __pyx_t_10, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 1258, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_drop_mine, __pyx_t_7, __pyx_t_10, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 1258, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_8, __pyx_t_10, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 1258, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1258, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1264:         )

 1265: 

 1266: '''

 1267: class SimState:

 1268:     __slots__ = ('timestep', 'ship_state', 'game_state', 'asteroids_pending_death', 'forecasted_asteroid_splits')

 1269: 

 1270:     def __init__(self, timestep: int, ship_state: Ship, game_state: Optional[GameState] = None, asteroids_pending_death: Optional[dict[int, list[Asteroid]]] = None, forecasted_asteroid_splits: Optional[list[Asteroid]] = None) -> None:

 1271:         self.timestep = timestep

 1272:         self.ship_state = ship_state

 1273:         self.game_state = game_state

 1274:         self.asteroids_pending_death = asteroids_pending_death

 1275:         self.forecasted_asteroid_splits = forecasted_asteroid_splits

 1276: 

 1277:     def __str__(self) -> str:

 1278:         return f'SimState(timestep={self.timestep}, ship_state={self.ship_state}, game_state={self.game_state}, asteroids_pending_death={self.asteroids_pending_death}, forecasted_asteroid_splits={self.forecasted_asteroid_splits})'

 1279: 

 1280:     def __repr__(self) -> str:

 1281:         return self.__str__()

 1282: 

 1283:     def copy(self) -> 'SimState':

 1284:         return SimState(

 1285:             timestep=self.timestep, 

 1286:             ship_state=self.ship_state.copy(), 

 1287:             game_state=self.game_state.copy() if self.game_state else None, 

 1288:             asteroids_pending_death=self.asteroids_pending_death.copy() if self.asteroids_pending_death else None, 

 1289:             forecasted_asteroid_splits=[a.copy() for a in self.forecasted_asteroid_splits] if self.forecasted_asteroid_splits else []

 1290:         )

 1291: '''

 1292: 

+1293: cdef class SimState:

struct __pyx_obj_14neo_controller_SimState {
  PyObject_HEAD
  int timestep;
  struct __pyx_obj_14neo_controller_Ship *ship_state;
  struct __pyx_obj_14neo_controller_GameState *game_state;
  PyObject *asteroids_pending_death;
  PyObject *forecasted_asteroid_splits;
};

+1294:     cdef public int timestep

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_8timestep_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8SimState_8timestep_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_8timestep___get__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_8timestep___get__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1294, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.SimState.timestep.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_8timestep_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_8timestep_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_8timestep_2__set__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_8timestep_2__set__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1294, __pyx_L1_error)
  __pyx_v_self->timestep = __pyx_t_1;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.SimState.timestep.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

+1295:     cdef public Ship ship_state

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_10ship_state_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8SimState_10ship_state_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_10ship_state___get__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_10ship_state___get__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_self->ship_state);
  __pyx_r = ((PyObject *)__pyx_v_self->ship_state);
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_10ship_state_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_10ship_state_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_10ship_state_2__set__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_10ship_state_2__set__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship))))) __PYX_ERR(0, 1295, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->ship_state);
  __Pyx_DECREF((PyObject *)__pyx_v_self->ship_state);
  __pyx_v_self->ship_state = ((struct __pyx_obj_14neo_controller_Ship *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.SimState.ship_state.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_10ship_state_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_10ship_state_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_10ship_state_4__del__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_10ship_state_4__del__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->ship_state);
  __Pyx_DECREF((PyObject *)__pyx_v_self->ship_state);
  __pyx_v_self->ship_state = ((struct __pyx_obj_14neo_controller_Ship *)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1296:     cdef public GameState game_state   # Can be None

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_10game_state_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8SimState_10game_state_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_10game_state___get__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_10game_state___get__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_self->game_state);
  __pyx_r = ((PyObject *)__pyx_v_self->game_state);
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_10game_state_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_10game_state_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_10game_state_2__set__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_10game_state_2__set__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState))))) __PYX_ERR(0, 1296, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->game_state);
  __Pyx_DECREF((PyObject *)__pyx_v_self->game_state);
  __pyx_v_self->game_state = ((struct __pyx_obj_14neo_controller_GameState *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.SimState.game_state.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_10game_state_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_10game_state_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_10game_state_4__del__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_10game_state_4__del__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->game_state);
  __Pyx_DECREF((PyObject *)__pyx_v_self->game_state);
  __pyx_v_self->game_state = ((struct __pyx_obj_14neo_controller_GameState *)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1297:     cdef public dict asteroids_pending_death  # dict[int, list[Asteroid]]

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_23asteroids_pending_death_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8SimState_23asteroids_pending_death_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_23asteroids_pending_death___get__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_23asteroids_pending_death___get__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->asteroids_pending_death);
  __pyx_r = __pyx_v_self->asteroids_pending_death;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_23asteroids_pending_death_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_23asteroids_pending_death_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_23asteroids_pending_death_2__set__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_23asteroids_pending_death_2__set__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(0, 1297, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->asteroids_pending_death);
  __Pyx_DECREF(__pyx_v_self->asteroids_pending_death);
  __pyx_v_self->asteroids_pending_death = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.SimState.asteroids_pending_death.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_23asteroids_pending_death_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_23asteroids_pending_death_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_23asteroids_pending_death_4__del__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_23asteroids_pending_death_4__del__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->asteroids_pending_death);
  __Pyx_DECREF(__pyx_v_self->asteroids_pending_death);
  __pyx_v_self->asteroids_pending_death = ((PyObject*)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1298:     cdef public list forecasted_asteroid_splits  # list[Asteroid]

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_26forecasted_asteroid_splits_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8SimState_26forecasted_asteroid_splits_1__get__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_26forecasted_asteroid_splits___get__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_26forecasted_asteroid_splits___get__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->forecasted_asteroid_splits);
  __pyx_r = __pyx_v_self->forecasted_asteroid_splits;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_26forecasted_asteroid_splits_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_26forecasted_asteroid_splits_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_26forecasted_asteroid_splits_2__set__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_26forecasted_asteroid_splits_2__set__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __pyx_t_1 = __pyx_v_value;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 1298, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->forecasted_asteroid_splits);
  __Pyx_DECREF(__pyx_v_self->forecasted_asteroid_splits);
  __pyx_v_self->forecasted_asteroid_splits = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.SimState.forecasted_asteroid_splits.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_26forecasted_asteroid_splits_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_26forecasted_asteroid_splits_5__del__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_26forecasted_asteroid_splits_4__del__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState_26forecasted_asteroid_splits_4__del__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  int __pyx_r;
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->forecasted_asteroid_splits);
  __Pyx_DECREF(__pyx_v_self->forecasted_asteroid_splits);
  __pyx_v_self->forecasted_asteroid_splits = ((PyObject*)Py_None);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1299: 

+1300:     def __cinit__(self,

/* Python wrapper */
static int __pyx_pw_14neo_controller_8SimState_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_14neo_controller_8SimState_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_timestep;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  PyObject *__pyx_v_asteroids_pending_death = 0;
  PyObject *__pyx_v_forecasted_asteroid_splits = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_timestep,&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_asteroids_pending_death,&__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1300, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < 0) __PYX_ERR(0, 1300, __pyx_L3_error)
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_14neo_controller_8SimState___cinit__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self, int __pyx_v_timestep, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, PyObject *__pyx_v_asteroids_pending_death, PyObject *__pyx_v_forecasted_asteroid_splits) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.SimState.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1301:                   int timestep,

 1302:                   Ship ship_state,

+1303:                   GameState game_state = None,

      if (!values[2]) values[2] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_14neo_controller_GameState *)Py_None));
/* … */
      if (!values[2]) values[2] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_14neo_controller_GameState *)Py_None));

+1304:                   asteroids_pending_death = None,

      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_None));
/* … */
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_None));

+1305:                   forecasted_asteroid_splits = None):

      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, i); __PYX_ERR(0, 1300, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1300, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1300, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1300, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
/* … */
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_timestep = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_timestep == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1301, __pyx_L3_error)
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
    __pyx_v_asteroids_pending_death = values[3];
    __pyx_v_forecasted_asteroid_splits = values[4];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, __pyx_nargs); __PYX_ERR(0, 1300, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.SimState.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 1, "ship_state", 0))) __PYX_ERR(0, 1302, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 1, "game_state", 0))) __PYX_ERR(0, 1303, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_8SimState___cinit__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self), __pyx_v_timestep, __pyx_v_ship_state, __pyx_v_game_state, __pyx_v_asteroids_pending_death, __pyx_v_forecasted_asteroid_splits);

+1306:         self.timestep = timestep

  __pyx_v_self->timestep = __pyx_v_timestep;

+1307:         self.ship_state = ship_state

  __Pyx_INCREF((PyObject *)__pyx_v_ship_state);
  __Pyx_GIVEREF((PyObject *)__pyx_v_ship_state);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->ship_state);
  __Pyx_DECREF((PyObject *)__pyx_v_self->ship_state);
  __pyx_v_self->ship_state = __pyx_v_ship_state;

+1308:         self.game_state = game_state

  __Pyx_INCREF((PyObject *)__pyx_v_game_state);
  __Pyx_GIVEREF((PyObject *)__pyx_v_game_state);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->game_state);
  __Pyx_DECREF((PyObject *)__pyx_v_self->game_state);
  __pyx_v_self->game_state = __pyx_v_game_state;

+1309:         self.asteroids_pending_death = asteroids_pending_death

  __pyx_t_1 = __pyx_v_asteroids_pending_death;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(0, 1309, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->asteroids_pending_death);
  __Pyx_DECREF(__pyx_v_self->asteroids_pending_death);
  __pyx_v_self->asteroids_pending_death = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1310:         self.forecasted_asteroid_splits = forecasted_asteroid_splits

  __pyx_t_1 = __pyx_v_forecasted_asteroid_splits;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 1310, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->forecasted_asteroid_splits);
  __Pyx_DECREF(__pyx_v_self->forecasted_asteroid_splits);
  __pyx_v_self->forecasted_asteroid_splits = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 1311: 

+1312:     def __str__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_3__str__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8SimState_3__str__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_2__str__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_2__str__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.SimState.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1313:         return (

  __Pyx_XDECREF(__pyx_r);

+1314:             f"SimState(timestep={self.timestep}, ship_state={self.ship_state}, "

  __pyx_t_1 = __Pyx_PyUnicode_From_int(__pyx_v_self->timestep, 0, ' ', 'd'); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_v_self->ship_state), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
/* … */
  __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 11, 18 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 13 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 26 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5));
  if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

+1315:             f"game_state={self.game_state}, asteroids_pending_death={self.asteroids_pending_death}, "

  __pyx_t_3 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_v_self->game_state), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_self->asteroids_pending_death, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+1316:             f"forecasted_asteroid_splits={self.forecasted_asteroid_splits})"

  __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_self->forecasted_asteroid_splits, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1316, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_SimState_timestep;
  __pyx_t_6[1] = __pyx_t_1;
  __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u_ship_state_2;
  __pyx_t_6[3] = __pyx_t_2;
  __pyx_t_6[4] = __pyx_mstate_global->__pyx_kp_u_game_state_2;
  __pyx_t_6[5] = __pyx_t_3;
  __pyx_t_6[6] = __pyx_mstate_global->__pyx_kp_u_asteroids_pending_death_2;
  __pyx_t_6[7] = __pyx_t_4;
  __pyx_t_6[8] = __pyx_mstate_global->__pyx_kp_u_forecasted_asteroid_splits_2;
  __pyx_t_6[9] = __pyx_t_5;
  __pyx_t_6[10] = __pyx_mstate_global->__pyx_kp_u__2;

 1317:         )

 1318: 

+1319:     def __repr__(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_5__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_14neo_controller_8SimState_5__repr__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_8SimState_4__repr__(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_4__repr__(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.SimState.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1320:         return self.__str__()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_v_self);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1320, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1321: 

+1322:     def copy(self):

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_8SimState_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_8SimState_7copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_8SimState_7copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_8SimState_7copy(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;}
  __pyx_r = __pyx_pf_14neo_controller_8SimState_6copy(((struct __pyx_obj_14neo_controller_SimState *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8SimState_6copy(struct __pyx_obj_14neo_controller_SimState *__pyx_v_self) {
  PyObject *__pyx_8genexpr7__pyx_v_a = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("neo_controller.SimState.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_8genexpr7__pyx_v_a);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_8SimState_7copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_SimState_copy, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[67])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < 0) __PYX_ERR(0, 1322, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1323:         # Deep copies for objects/lists, shallow for primitives

+1324:         return SimState(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState); 

+1325:             timestep=self.timestep,

  __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_self->timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1325, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+1326:             ship_state=self.ship_state.copy(),

  __pyx_t_6 = ((PyObject *)__pyx_v_self->ship_state);
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_7 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
    __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1326, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }

+1327:             game_state=self.game_state.copy() if self.game_state is not None else None,

  __pyx_t_8 = (((PyObject *)__pyx_v_self->game_state) != Py_None);
  if (__pyx_t_8) {
    __pyx_t_10 = ((PyObject *)__pyx_v_self->game_state);
    __Pyx_INCREF(__pyx_t_10);
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
      __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1327, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __pyx_t_6 = __pyx_t_9;
    __pyx_t_9 = 0;
  } else {
    __Pyx_INCREF(Py_None);
    __pyx_t_6 = Py_None;
  }

+1328:             asteroids_pending_death=self.asteroids_pending_death.copy() if self.asteroids_pending_death is not None else None,

  __pyx_t_8 = (__pyx_v_self->asteroids_pending_death != ((PyObject*)Py_None));
  if (__pyx_t_8) {
    if (unlikely(__pyx_v_self->asteroids_pending_death == Py_None)) {
      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "copy");
      __PYX_ERR(0, 1328, __pyx_L1_error)
    }
    __pyx_t_10 = PyDict_Copy(__pyx_v_self->asteroids_pending_death); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1328, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = __pyx_t_10;
    __pyx_t_10 = 0;
  } else {
    __Pyx_INCREF(Py_None);
    __pyx_t_9 = Py_None;
  }

+1329:             forecasted_asteroid_splits=[a.copy() for a in self.forecasted_asteroid_splits] if self.forecasted_asteroid_splits is not None else []

  __pyx_t_8 = (__pyx_v_self->forecasted_asteroid_splits != ((PyObject*)Py_None));
  if (__pyx_t_8) {
    { /* enter inner scope */
      __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1329, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_11);
      if (unlikely(__pyx_v_self->forecasted_asteroid_splits == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
        __PYX_ERR(0, 1329, __pyx_L5_error)
      }
      __pyx_t_12 = __pyx_v_self->forecasted_asteroid_splits; __Pyx_INCREF(__pyx_t_12);
      __pyx_t_13 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_12);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1329, __pyx_L5_error)
          #endif
          if (__pyx_t_13 >= __pyx_temp) break;
        }
        __pyx_t_14 = __Pyx_PyList_GetItemRef(__pyx_t_12, __pyx_t_13);
        ++__pyx_t_13;
        if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1329, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_14);
        __Pyx_XDECREF_SET(__pyx_8genexpr7__pyx_v_a, __pyx_t_14);
        __pyx_t_14 = 0;
        __pyx_t_15 = __pyx_8genexpr7__pyx_v_a;
        __Pyx_INCREF(__pyx_t_15);
        __pyx_t_7 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_15, NULL};
          __pyx_t_14 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
          if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1329, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_14);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_11, (PyObject*)__pyx_t_14))) __PYX_ERR(0, 1329, __pyx_L5_error)
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      }
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_8genexpr7__pyx_v_a); __pyx_8genexpr7__pyx_v_a = 0;
      goto __pyx_L9_exit_scope;
      __pyx_L5_error:;
      __Pyx_XDECREF(__pyx_8genexpr7__pyx_v_a); __pyx_8genexpr7__pyx_v_a = 0;
      goto __pyx_L1_error;
      __pyx_L9_exit_scope:;
    } /* exit inner scope */
    __pyx_t_10 = __pyx_t_11;
    __pyx_t_11 = 0;
  } else {
    __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_10 = __pyx_t_11;
    __pyx_t_11 = 0;
  }
  __pyx_t_7 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_11 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1324, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_4, __pyx_t_11, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1324, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_5, __pyx_t_11, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 1324, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, __pyx_t_6, __pyx_t_11, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 1324, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_9, __pyx_t_11, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 1324, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_10, __pyx_t_11, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 1324, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_11);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1324, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((PyObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1330:         )

 1331: 

 1332: 

+1333: class AsteroidDict(TypedDict):#, total=False):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_AsteroidDict, __pyx_mstate_global->__pyx_n_u_AsteroidDict, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__pyx_t_4 != __pyx_t_10) {
    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_10) < 0))) __PYX_ERR(0, 1333, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_position, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1333, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1333, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_size, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1333, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_mass, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1333, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_radius, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1333, __pyx_L1_error)
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_annotations, __pyx_t_10) < 0) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* … */
  __pyx_t_10 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_AsteroidDict, __pyx_t_4, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AsteroidDict, __pyx_t_10) < 0) __PYX_ERR(0, 1333, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1334:     position: tuple[float, float]

 1335:     velocity: tuple[float, float]

 1336:     size: int

 1337:     mass: float

 1338:     radius: float

 1339:     #timesteps_until_appearance: int

 1340: 

 1341: 

+1342: class ShipDict(TypedDict, total=False):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_total, Py_False) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  __pyx_t_10 = __Pyx_Py3MetaclassGet(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_10, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShipDict, __pyx_mstate_global->__pyx_n_u_ShipDict, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__pyx_t_4 != __pyx_t_5) {
    if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 1342, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyDict_NewPresized(18); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_respawning, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_position, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_heading, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mass, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_radius, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_id, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_team, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lives_remaining, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_bullets_remaining, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mines_remaining, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_can_fire, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_fire_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_thrust_range, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_turn_rate_range, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_max_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_drag, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_annotations, __pyx_t_5) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_ShipDict, __pyx_t_4, __pyx_t_3, __pyx_t_2, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ShipDict, __pyx_t_5) < 0) __PYX_ERR(0, 1342, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1343:     is_respawning: bool

 1344:     position: tuple[float, float]

 1345:     velocity: tuple[float, float]

 1346:     speed: float

 1347:     heading: float

 1348:     mass: float

 1349:     radius: float

 1350:     id: int

 1351:     team: str

 1352:     lives_remaining: int

 1353:     bullets_remaining: int

 1354:     mines_remaining: int

 1355:     can_fire: bool

 1356:     fire_rate: float

 1357:     thrust_range: tuple[float, float]

 1358:     turn_rate_range: tuple[float, float]

 1359:     max_speed: float

 1360:     drag: float

 1361: 

 1362: 

+1363: class MineDict(TypedDict):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_10, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_MineDict, __pyx_mstate_global->__pyx_n_u_MineDict, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__pyx_t_4 != __pyx_t_2) {
    if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 1363, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_position, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1363, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mass, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1363, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fuse_time, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1363, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_remaining_time, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1363, __pyx_L1_error)
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_annotations, __pyx_t_2) < 0) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_MineDict, __pyx_t_4, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MineDict, __pyx_t_2) < 0) __PYX_ERR(0, 1363, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1364:     position: tuple[float, float]

 1365:     mass: float

 1366:     fuse_time: float

 1367:     remaining_time: float

 1368: 

 1369: 

+1370: class BulletDict(TypedDict):#, total=False):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_BulletDict, __pyx_mstate_global->__pyx_n_u_BulletDict, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__pyx_t_4 != __pyx_t_10) {
    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_10) < 0))) __PYX_ERR(0, 1370, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_position, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1370, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1370, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_heading, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1370, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_mass, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1370, __pyx_L1_error)
  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_annotations, __pyx_t_10) < 0) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* … */
  __pyx_t_10 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BulletDict, __pyx_t_4, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BulletDict, __pyx_t_10) < 0) __PYX_ERR(0, 1370, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1371:     # Since I add in the tail delta myself, it may or may not exist.

 1372:     position: tuple[float, float]

 1373:     velocity: tuple[float, float]

 1374:     heading: float

 1375:     mass: float

 1376:     #tail_delta: tuple[float, float]

 1377: 

 1378: 

+1379: class GameStateDict(TypedDict):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_10 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_GameStateDict, __pyx_mstate_global->__pyx_n_u_GameStateDict, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (__pyx_t_4 != __pyx_t_3) {
    if (unlikely((PyDict_SetItemString(__pyx_t_10, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 1379, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_mstate_global->__pyx_kp_u_list_AsteroidDict) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ships, __pyx_mstate_global->__pyx_kp_u_list_ShipDict) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_mstate_global->__pyx_kp_u_list_BulletDict) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_mines, __pyx_mstate_global->__pyx_kp_u_list_MineDict) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_map_size, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_time, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_delta_time, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sim_frame, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_time_limit, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_annotations, __pyx_t_3) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_GameStateDict, __pyx_t_4, __pyx_t_10, NULL, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_GameStateDict, __pyx_t_3) < 0) __PYX_ERR(0, 1379, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1380:     asteroids: list[AsteroidDict]

 1381:     ships: list[ShipDict]

 1382:     bullets: list[BulletDict]

 1383:     mines: list[MineDict]

 1384:     map_size: tuple[float, float]

 1385:     time: float

 1386:     delta_time: float

 1387:     sim_frame: int

 1388:     time_limit: float

 1389: 

 1390: 

+1391: class BasePlanningGameState(TypedDict):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_10, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_BasePlanningGameState, __pyx_mstate_global->__pyx_n_u_BasePlanningGameState, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__pyx_t_4 != __pyx_t_2) {
    if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 1391, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_respawning, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_mstate_global->__pyx_kp_u_dict_int_list_Asteroid) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_mstate_global->__pyx_kp_u_set_tuple_float_float) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_annotations, __pyx_t_2) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_BasePlanningGameState, __pyx_t_4, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BasePlanningGameState, __pyx_t_2) < 0) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1392:     timestep: int

 1393:     respawning: bool

 1394:     ship_state: Ship

 1395:     game_state: GameState

 1396:     ship_respawn_timer: float

 1397:     asteroids_pending_death: dict[int, list[Asteroid]]

 1398:     forecasted_asteroid_splits: list[Asteroid]

 1399:     last_timestep_fired: int

 1400:     last_timestep_mined: int

 1401:     mine_positions_placed: set[tuple[float, float]]

 1402:     fire_next_timestep_flag: bool

 1403: 

 1404: 

+1405: class CompletedSimulation(TypedDict, total=False):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TypedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_total, Py_False) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  __pyx_t_2 = __Pyx_Py3MetaclassGet(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_CompletedSimulation, __pyx_mstate_global->__pyx_n_u_CompletedSimulation, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (__pyx_t_4 != __pyx_t_10) {
    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_10) < 0))) __PYX_ERR(0, 1405, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_sim, __pyx_mstate_global->__pyx_kp_u_Matrix_2) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_fitness, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_fitness_breakdown, __pyx_mstate_global->__pyx_kp_u_tuple_float_float_float_float_fl) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_action_type, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_state_type, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_maneuver_tuple, __pyx_mstate_global->__pyx_kp_u_Optional_tuple_float_float_float) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_annotations, __pyx_t_10) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* … */
  __pyx_t_10 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_CompletedSimulation, __pyx_t_4, __pyx_t_5, __pyx_t_3, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CompletedSimulation, __pyx_t_10) < 0) __PYX_ERR(0, 1405, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1406:     sim: 'Matrix'

 1407:     fitness: float

 1408:     fitness_breakdown: tuple[float, float, float, float, float, float, float, float, float]

 1409:     action_type: str

 1410:     state_type: str

 1411:     maneuver_tuple: Optional[tuple[float, float, float, int, float]]

 1412: 

 1413: 

+1414: def create_game_state_from_dict(game_state_dict: GameStateDict) -> GameState:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_GameState *__pyx_pw_14neo_controller_1create_game_state_from_dict(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_1create_game_state_from_dict = {"create_game_state_from_dict", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_1create_game_state_from_dict, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static struct __pyx_obj_14neo_controller_GameState *__pyx_pw_14neo_controller_1create_game_state_from_dict(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_game_state_dict = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_GameState *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create_game_state_from_dict (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state_dict,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1414, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1414, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "create_game_state_from_dict", 0) < 0) __PYX_ERR(0, 1414, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("create_game_state_from_dict", 1, 1, 1, i); __PYX_ERR(0, 1414, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1414, __pyx_L3_error)
    }
    __pyx_v_game_state_dict = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create_game_state_from_dict", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1414, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.create_game_state_from_dict", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_create_game_state_from_dict(__pyx_self, __pyx_v_game_state_dict);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_GameState *__pyx_pf_14neo_controller_create_game_state_from_dict(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_game_state_dict) {
  PyObject *__pyx_v_asteroids = NULL;
  PyObject *__pyx_v_ships = NULL;
  PyObject *__pyx_v_bullets = NULL;
  PyObject *__pyx_v_mines = NULL;
  PyObject *__pyx_v_map_size = NULL;
  PyObject *__pyx_v_time = NULL;
  PyObject *__pyx_v_delta_time = NULL;
  PyObject *__pyx_v_sim_frame = NULL;
  PyObject *__pyx_v_time_limit = NULL;
  PyObject *__pyx_8genexpr8__pyx_v_asteroid = NULL;
  PyObject *__pyx_8genexpr9__pyx_v_ship = NULL;
  PyObject *__pyx_9genexpr10__pyx_v_bullet = NULL;
  PyObject *__pyx_9genexpr11__pyx_v_mine = NULL;
  struct __pyx_obj_14neo_controller_GameState *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.create_game_state_from_dict", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_asteroids);
  __Pyx_XDECREF(__pyx_v_ships);
  __Pyx_XDECREF(__pyx_v_bullets);
  __Pyx_XDECREF(__pyx_v_mines);
  __Pyx_XDECREF(__pyx_v_map_size);
  __Pyx_XDECREF(__pyx_v_time);
  __Pyx_XDECREF(__pyx_v_delta_time);
  __Pyx_XDECREF(__pyx_v_sim_frame);
  __Pyx_XDECREF(__pyx_v_time_limit);
  __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_ship);
  __Pyx_XDECREF(__pyx_9genexpr10__pyx_v_bullet);
  __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_mine);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state_dict, __pyx_mstate_global->__pyx_n_u_GameStateDict) < 0) __PYX_ERR(0, 1414, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 1414, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_1create_game_state_from_dict, 0, __pyx_mstate_global->__pyx_n_u_create_game_state_from_dict, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[70])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_create_game_state_from_dict, __pyx_t_3) < 0) __PYX_ERR(0, 1414, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1415:     asteroids = [Asteroid(**asteroid) for asteroid in game_state_dict['asteroids']]

  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1415, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1415, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
      __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3);
      __pyx_t_4 = 0;
      __pyx_t_5 = NULL;
    } else {
      __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1415, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1415, __pyx_L5_error)
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    for (;;) {
      if (likely(!__pyx_t_5)) {
        if (likely(PyList_CheckExact(__pyx_t_3))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1415, __pyx_L5_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_4);
          ++__pyx_t_4;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1415, __pyx_L5_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4));
          #else
          __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4);
          #endif
          ++__pyx_t_4;
        }
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1415, __pyx_L5_error)
      } else {
        __pyx_t_2 = __pyx_t_5(__pyx_t_3);
        if (unlikely(!__pyx_t_2)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1415, __pyx_L5_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_8genexpr8__pyx_v_asteroid, __pyx_t_2);
      __pyx_t_2 = 0;
      if (unlikely(__pyx_8genexpr8__pyx_v_asteroid == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
        __PYX_ERR(0, 1415, __pyx_L5_error)
      }
      if (likely(PyDict_CheckExact(__pyx_8genexpr8__pyx_v_asteroid))) {
        __pyx_t_2 = PyDict_Copy(__pyx_8genexpr8__pyx_v_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1415, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_2);
      } else {
        __pyx_t_2 = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, __pyx_8genexpr8__pyx_v_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1415, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid), __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1415, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 1415, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_asteroid); __pyx_8genexpr8__pyx_v_asteroid = 0;
    goto __pyx_L9_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_asteroid); __pyx_8genexpr8__pyx_v_asteroid = 0;
    goto __pyx_L1_error;
    __pyx_L9_exit_scope:;
  } /* exit inner scope */
  __pyx_v_asteroids = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1416:     ships = [Ship(**ship) for ship in game_state_dict['ships']]

  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1416, __pyx_L12_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_ships); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1416, __pyx_L12_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
      __pyx_t_6 = __pyx_t_3; __Pyx_INCREF(__pyx_t_6);
      __pyx_t_4 = 0;
      __pyx_t_5 = NULL;
    } else {
      __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1416, __pyx_L12_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1416, __pyx_L12_error)
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    for (;;) {
      if (likely(!__pyx_t_5)) {
        if (likely(PyList_CheckExact(__pyx_t_6))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1416, __pyx_L12_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_4);
          ++__pyx_t_4;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1416, __pyx_L12_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4));
          #else
          __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_4);
          #endif
          ++__pyx_t_4;
        }
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1416, __pyx_L12_error)
      } else {
        __pyx_t_3 = __pyx_t_5(__pyx_t_6);
        if (unlikely(!__pyx_t_3)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1416, __pyx_L12_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_XDECREF_SET(__pyx_8genexpr9__pyx_v_ship, __pyx_t_3);
      __pyx_t_3 = 0;
      if (unlikely(__pyx_8genexpr9__pyx_v_ship == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
        __PYX_ERR(0, 1416, __pyx_L12_error)
      }
      if (likely(PyDict_CheckExact(__pyx_8genexpr9__pyx_v_ship))) {
        __pyx_t_3 = PyDict_Copy(__pyx_8genexpr9__pyx_v_ship); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1416, __pyx_L12_error)
        __Pyx_GOTREF(__pyx_t_3);
      } else {
        __pyx_t_3 = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, __pyx_8genexpr9__pyx_v_ship); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1416, __pyx_L12_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship), __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1416, __pyx_L12_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1416, __pyx_L12_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_ship); __pyx_8genexpr9__pyx_v_ship = 0;
    goto __pyx_L16_exit_scope;
    __pyx_L12_error:;
    __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_ship); __pyx_8genexpr9__pyx_v_ship = 0;
    goto __pyx_L1_error;
    __pyx_L16_exit_scope:;
  } /* exit inner scope */
  __pyx_v_ships = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1417:     bullets = [Bullet(**bullet) for bullet in game_state_dict['bullets']]

  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1417, __pyx_L19_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1417, __pyx_L19_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) {
      __pyx_t_2 = __pyx_t_6; __Pyx_INCREF(__pyx_t_2);
      __pyx_t_4 = 0;
      __pyx_t_5 = NULL;
    } else {
      __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1417, __pyx_L19_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1417, __pyx_L19_error)
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    for (;;) {
      if (likely(!__pyx_t_5)) {
        if (likely(PyList_CheckExact(__pyx_t_2))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1417, __pyx_L19_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4);
          ++__pyx_t_4;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1417, __pyx_L19_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_6 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4));
          #else
          __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4);
          #endif
          ++__pyx_t_4;
        }
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1417, __pyx_L19_error)
      } else {
        __pyx_t_6 = __pyx_t_5(__pyx_t_2);
        if (unlikely(!__pyx_t_6)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1417, __pyx_L19_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_XDECREF_SET(__pyx_9genexpr10__pyx_v_bullet, __pyx_t_6);
      __pyx_t_6 = 0;
      if (unlikely(__pyx_9genexpr10__pyx_v_bullet == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
        __PYX_ERR(0, 1417, __pyx_L19_error)
      }
      if (likely(PyDict_CheckExact(__pyx_9genexpr10__pyx_v_bullet))) {
        __pyx_t_6 = PyDict_Copy(__pyx_9genexpr10__pyx_v_bullet); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1417, __pyx_L19_error)
        __Pyx_GOTREF(__pyx_t_6);
      } else {
        __pyx_t_6 = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, __pyx_9genexpr10__pyx_v_bullet); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1417, __pyx_L19_error)
        __Pyx_GOTREF(__pyx_t_6);
      }
      __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet), __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1417, __pyx_L19_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 1417, __pyx_L19_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_9genexpr10__pyx_v_bullet); __pyx_9genexpr10__pyx_v_bullet = 0;
    goto __pyx_L23_exit_scope;
    __pyx_L19_error:;
    __Pyx_XDECREF(__pyx_9genexpr10__pyx_v_bullet); __pyx_9genexpr10__pyx_v_bullet = 0;
    goto __pyx_L1_error;
    __pyx_L23_exit_scope:;
  } /* exit inner scope */
  __pyx_v_bullets = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1418:     mines = [Mine(**mine) for mine in game_state_dict['mines']]

  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1418, __pyx_L26_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1418, __pyx_L26_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
      __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3);
      __pyx_t_4 = 0;
      __pyx_t_5 = NULL;
    } else {
      __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1418, __pyx_L26_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1418, __pyx_L26_error)
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    for (;;) {
      if (likely(!__pyx_t_5)) {
        if (likely(PyList_CheckExact(__pyx_t_3))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1418, __pyx_L26_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_4);
          ++__pyx_t_4;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1418, __pyx_L26_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4));
          #else
          __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4);
          #endif
          ++__pyx_t_4;
        }
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1418, __pyx_L26_error)
      } else {
        __pyx_t_2 = __pyx_t_5(__pyx_t_3);
        if (unlikely(!__pyx_t_2)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1418, __pyx_L26_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_9genexpr11__pyx_v_mine, __pyx_t_2);
      __pyx_t_2 = 0;
      if (unlikely(__pyx_9genexpr11__pyx_v_mine == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
        __PYX_ERR(0, 1418, __pyx_L26_error)
      }
      if (likely(PyDict_CheckExact(__pyx_9genexpr11__pyx_v_mine))) {
        __pyx_t_2 = PyDict_Copy(__pyx_9genexpr11__pyx_v_mine); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1418, __pyx_L26_error)
        __Pyx_GOTREF(__pyx_t_2);
      } else {
        __pyx_t_2 = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, __pyx_9genexpr11__pyx_v_mine); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1418, __pyx_L26_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Mine), __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1418, __pyx_L26_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 1418, __pyx_L26_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_mine); __pyx_9genexpr11__pyx_v_mine = 0;
    goto __pyx_L30_exit_scope;
    __pyx_L26_error:;
    __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_mine); __pyx_9genexpr11__pyx_v_mine = 0;
    goto __pyx_L1_error;
    __pyx_L30_exit_scope:;
  } /* exit inner scope */
  __pyx_v_mines = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1419:     map_size = game_state_dict['map_size']

  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1419, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_map_size = __pyx_t_1;
  __pyx_t_1 = 0;

+1420:     time = game_state_dict['time']

  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_time = __pyx_t_1;
  __pyx_t_1 = 0;

+1421:     delta_time = game_state_dict['delta_time']

  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_delta_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_delta_time = __pyx_t_1;
  __pyx_t_1 = 0;

+1422:     sim_frame = game_state_dict['sim_frame']

  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_sim_frame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_sim_frame = __pyx_t_1;
  __pyx_t_1 = 0;

+1423:     time_limit = game_state_dict['time_limit']

  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_game_state_dict, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_time_limit = __pyx_t_1;
  __pyx_t_1 = 0;

+1424:     return GameState(asteroids=asteroids, ships=ships, bullets=bullets, mines=mines, map_size=map_size, time=time, delta_time=delta_time, sim_frame=sim_frame, time_limit=time_limit)

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __pyx_t_3 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState);
  __pyx_t_6 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState); 
  __pyx_t_7 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 9 : 0)] = {__pyx_t_3, NULL};
    __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1424, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids, __pyx_v_asteroids, __pyx_t_2, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ships, __pyx_v_ships, __pyx_t_2, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_bullets, __pyx_v_bullets, __pyx_t_2, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mines, __pyx_v_mines, __pyx_t_2, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_map_size, __pyx_v_map_size, __pyx_t_2, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_time, __pyx_v_time, __pyx_t_2, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_delta_time, __pyx_v_delta_time, __pyx_t_2, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_sim_frame, __pyx_v_sim_frame, __pyx_t_2, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_time_limit, __pyx_v_time_limit, __pyx_t_2, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 1424, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1424, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((struct __pyx_obj_14neo_controller_GameState *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1425: 

 1426: 

+1427: def create_ship_from_dict(ship_state_dict: ShipDict) -> Ship:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_Ship *__pyx_pw_14neo_controller_3create_ship_from_dict(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_3create_ship_from_dict = {"create_ship_from_dict", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_3create_ship_from_dict, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static struct __pyx_obj_14neo_controller_Ship *__pyx_pw_14neo_controller_3create_ship_from_dict(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_ship_state_dict = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_Ship *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create_ship_from_dict (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ship_state_dict,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1427, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1427, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "create_ship_from_dict", 0) < 0) __PYX_ERR(0, 1427, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("create_ship_from_dict", 1, 1, 1, i); __PYX_ERR(0, 1427, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1427, __pyx_L3_error)
    }
    __pyx_v_ship_state_dict = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create_ship_from_dict", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1427, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.create_ship_from_dict", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_2create_ship_from_dict(__pyx_self, __pyx_v_ship_state_dict);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_Ship *__pyx_pf_14neo_controller_2create_ship_from_dict(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ship_state_dict) {
  struct __pyx_obj_14neo_controller_Ship *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.create_ship_from_dict", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1427, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_state_dict, __pyx_mstate_global->__pyx_n_u_ShipDict) < 0) __PYX_ERR(0, 1427, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 1427, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_3create_ship_from_dict, 0, __pyx_mstate_global->__pyx_n_u_create_ship_from_dict, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[71])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1427, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_create_ship_from_dict, __pyx_t_4) < 0) __PYX_ERR(0, 1427, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1428:     return Ship(**ship_state_dict)

  __Pyx_XDECREF((PyObject *)__pyx_r);
  if (unlikely(__pyx_v_ship_state_dict == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(0, 1428, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_ship_state_dict))) {
    __pyx_t_1 = PyDict_Copy(__pyx_v_ship_state_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1428, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    __pyx_t_1 = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, __pyx_v_ship_state_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1428, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship), __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1428, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = ((struct __pyx_obj_14neo_controller_Ship *)__pyx_t_2);
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1429: 

 1430: 

+1431: def degrees(x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_5degrees(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_4degrees, "Convert radians to degrees.");
static PyMethodDef __pyx_mdef_14neo_controller_5degrees = {"degrees", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_5degrees, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_4degrees};
static PyObject *__pyx_pw_14neo_controller_5degrees(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("degrees (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1431, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1431, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "degrees", 0) < 0) __PYX_ERR(0, 1431, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("degrees", 1, 1, 1, i); __PYX_ERR(0, 1431, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1431, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1431, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("degrees", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1431, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.degrees", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_4degrees(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_4degrees(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.degrees", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1431, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1431, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1431, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_5degrees, 0, __pyx_mstate_global->__pyx_n_u_degrees, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[72])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1431, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_degrees, __pyx_t_3) < 0) __PYX_ERR(0, 1431, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1432:     '''Convert radians to degrees.'''

+1433:     return x*RAD_TO_DEG

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble((__pyx_v_x * __pyx_v_14neo_controller_RAD_TO_DEG)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1433, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1434: 

 1435: 

+1436: def radians(x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_7radians(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_6radians, "Convert degrees to radians.");
static PyMethodDef __pyx_mdef_14neo_controller_7radians = {"radians", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_7radians, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_6radians};
static PyObject *__pyx_pw_14neo_controller_7radians(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("radians (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1436, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1436, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "radians", 0) < 0) __PYX_ERR(0, 1436, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("radians", 1, 1, 1, i); __PYX_ERR(0, 1436, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1436, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1436, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("radians", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1436, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.radians", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6radians(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6radians(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.radians", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1436, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1436, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1436, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_7radians, 0, __pyx_mstate_global->__pyx_n_u_radians, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[73])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1436, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_radians, __pyx_t_4) < 0) __PYX_ERR(0, 1436, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1437:     '''Convert degrees to radians.'''

+1438:     return x*DEG_TO_RAD

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble((__pyx_v_x * __pyx_v_14neo_controller_DEG_TO_RAD)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1438, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1439: 

 1440: 

+1441: def sign(x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_9sign(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_9sign = {"sign", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_9sign, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_9sign(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sign (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1441, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1441, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "sign", 0) < 0) __PYX_ERR(0, 1441, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("sign", 1, 1, 1, i); __PYX_ERR(0, 1441, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1441, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1441, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("sign", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1441, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.sign", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_8sign(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_8sign(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1441, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1441, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1441, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_9sign, 0, __pyx_mstate_global->__pyx_n_u_sign, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1441, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_sign, __pyx_t_3) < 0) __PYX_ERR(0, 1441, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1442:     if x >= 0.0:

  __pyx_t_1 = (__pyx_v_x >= 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1443:         return 1.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_1_0;
    goto __pyx_L0;

 1444:     else:

+1445:         return -1.0

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_1_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_neg_1_0;
    goto __pyx_L0;
  }

 1446: 

 1447: 

+1448: def dist(point_1: tuple[float, float], point_2: tuple[float, float]) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_11dist(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_10dist, "Calculate the Euclidean distance between two points in 2D space.");
static PyMethodDef __pyx_mdef_14neo_controller_11dist = {"dist", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_11dist, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_10dist};
static PyObject *__pyx_pw_14neo_controller_11dist(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __pyx_ctuple_double__and_double __pyx_v_point_1;
  __pyx_ctuple_double__and_double __pyx_v_point_2;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("dist (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_point_1,&__pyx_mstate_global->__pyx_n_u_point_2,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1448, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1448, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1448, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "dist", 0) < 0) __PYX_ERR(0, 1448, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("dist", 1, 2, 2, i); __PYX_ERR(0, 1448, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1448, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1448, __pyx_L3_error)
    }
    __pyx_v_point_1 = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1448, __pyx_L3_error)
    __pyx_v_point_2 = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1448, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("dist", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1448, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.dist", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_10dist(__pyx_self, __pyx_v_point_1, __pyx_v_point_2);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_10dist(CYTHON_UNUSED PyObject *__pyx_self, __pyx_ctuple_double__and_double __pyx_v_point_1, __pyx_ctuple_double__and_double __pyx_v_point_2) {
  double __pyx_v_dx;
  double __pyx_v_dy;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.dist", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1448, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_point_1, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1448, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_point_2, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1448, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1448, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_11dist, 0, __pyx_mstate_global->__pyx_n_u_dist, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1448, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_dist, __pyx_t_4) < 0) __PYX_ERR(0, 1448, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
struct __pyx_ctuple_double__and_double {
  double f0;
  double f1;
};

 1449:     '''Calculate the Euclidean distance between two points in 2D space.'''

+1450:     dx = point_1[0] - point_2[0]

  __pyx_v_dx = (__pyx_v_point_1.f0 - __pyx_v_point_2.f0);

+1451:     dy = point_1[1] - point_2[1]

  __pyx_v_dy = (__pyx_v_point_1.f1 - __pyx_v_point_2.f1);

+1452:     return sqrt(dx*dx + dy*dy)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(sqrt(((__pyx_v_dx * __pyx_v_dx) + (__pyx_v_dy * __pyx_v_dy)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1452, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1453: 

 1454: 

+1455: def is_close(x: float, y: float) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13is_close(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_12is_close, "Check if two numbers are close based on absolute tolerance.");
static PyMethodDef __pyx_mdef_14neo_controller_13is_close = {"is_close", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13is_close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_12is_close};
static PyObject *__pyx_pw_14neo_controller_13is_close(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  double __pyx_v_y;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_close (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_y,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1455, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1455, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1455, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "is_close", 0) < 0) __PYX_ERR(0, 1455, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("is_close", 1, 2, 2, i); __PYX_ERR(0, 1455, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1455, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1455, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1455, __pyx_L3_error)
    __pyx_v_y = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1455, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("is_close", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1455, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.is_close", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_12is_close(__pyx_self, __pyx_v_x, __pyx_v_y);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_12is_close(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x, double __pyx_v_y) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.is_close", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1455, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1455, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1455, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1455, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13is_close, 0, __pyx_mstate_global->__pyx_n_u_is_close, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[76])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1455, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_is_close, __pyx_t_3) < 0) __PYX_ERR(0, 1455, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1456:     '''Check if two numbers are close based on absolute tolerance.'''

+1457:     return abs(x - y) <= EPS

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = fabs((__pyx_v_x - __pyx_v_y)); 
  __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_t_1 <= __pyx_v_14neo_controller_EPS)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1457, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1458: 

 1459: 

+1460: def is_close_to_zero(x: float) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_15is_close_to_zero(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_14is_close_to_zero, "Check if a number is close to zero.");
static PyMethodDef __pyx_mdef_14neo_controller_15is_close_to_zero = {"is_close_to_zero", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_15is_close_to_zero, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_14is_close_to_zero};
static PyObject *__pyx_pw_14neo_controller_15is_close_to_zero(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_close_to_zero (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1460, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1460, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "is_close_to_zero", 0) < 0) __PYX_ERR(0, 1460, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("is_close_to_zero", 1, 1, 1, i); __PYX_ERR(0, 1460, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1460, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1460, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("is_close_to_zero", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1460, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.is_close_to_zero", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_14is_close_to_zero(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_14is_close_to_zero(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.is_close_to_zero", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1460, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1460, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1460, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_15is_close_to_zero, 0, __pyx_mstate_global->__pyx_n_u_is_close_to_zero, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[77])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1460, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_is_close_to_zero, __pyx_t_4) < 0) __PYX_ERR(0, 1460, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1461:     '''Check if a number is close to zero.'''

+1462:     return abs(x) <= EPS

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = fabs(__pyx_v_x); 
  __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_t_1 <= __pyx_v_14neo_controller_EPS)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1462, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1463: 

 1464: 

+1465: def super_fast_acos(x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_17super_fast_acos(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_17super_fast_acos = {"super_fast_acos", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_17super_fast_acos, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_17super_fast_acos(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("super_fast_acos (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1465, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1465, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "super_fast_acos", 0) < 0) __PYX_ERR(0, 1465, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("super_fast_acos", 1, 1, 1, i); __PYX_ERR(0, 1465, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1465, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1465, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("super_fast_acos", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1465, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.super_fast_acos", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_16super_fast_acos(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_16super_fast_acos(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.super_fast_acos", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1465, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1465, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1465, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_17super_fast_acos, 0, __pyx_mstate_global->__pyx_n_u_super_fast_acos, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[78])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1465, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_super_fast_acos, __pyx_t_3) < 0) __PYX_ERR(0, 1465, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1466:     return (-0.69813170079773212*x*x - 0.87266462599716477)*x + 1.5707963267948966

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble((((((-0.69813170079773212 * __pyx_v_x) * __pyx_v_x) - 0.87266462599716477) * __pyx_v_x) + 1.5707963267948966)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1466, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1467: 

 1468: 

+1469: def fast_acos(x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_19fast_acos(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_19fast_acos = {"fast_acos", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_19fast_acos, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_19fast_acos(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fast_acos (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1469, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1469, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "fast_acos", 0) < 0) __PYX_ERR(0, 1469, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("fast_acos", 1, 1, 1, i); __PYX_ERR(0, 1469, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1469, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1469, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("fast_acos", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1469, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.fast_acos", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18fast_acos(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18fast_acos(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  double __pyx_v_negate;
  double __pyx_v_ret;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.fast_acos", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1469, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1469, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_19fast_acos, 0, __pyx_mstate_global->__pyx_n_u_fast_acos, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[79])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_fast_acos, __pyx_t_4) < 0) __PYX_ERR(0, 1469, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1470:     negate = float(x < 0)

  __pyx_v_negate = ((double)(__pyx_v_x < 0.0));

+1471:     x = abs(x)

  __pyx_t_1 = fabs(__pyx_v_x); 
  __pyx_v_x = __pyx_t_1;

+1472:     ret = (((-0.0187293*x + 0.0742610)*x - 0.2121144)*x + 1.5707288)*sqrt(1.0 - x)

  __pyx_v_ret = (((((((-0.0187293 * __pyx_v_x) + 0.0742610) * __pyx_v_x) - 0.2121144) * __pyx_v_x) + 1.5707288) * sqrt((1.0 - __pyx_v_x)));

+1473:     return negate*pi + ret - 2.0*negate*ret

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble((((__pyx_v_negate * M_PI) + __pyx_v_ret) - ((2.0 * __pyx_v_negate) * __pyx_v_ret))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1473, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1474: 

 1475: 

+1476: def super_fast_asin(x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_21super_fast_asin(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_21super_fast_asin = {"super_fast_asin", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_21super_fast_asin, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_21super_fast_asin(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("super_fast_asin (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1476, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1476, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "super_fast_asin", 0) < 0) __PYX_ERR(0, 1476, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("super_fast_asin", 1, 1, 1, i); __PYX_ERR(0, 1476, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1476, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1476, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("super_fast_asin", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1476, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.super_fast_asin", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_20super_fast_asin(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_20super_fast_asin(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  double __pyx_v_x_square;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.super_fast_asin", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1476, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1476, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1476, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_21super_fast_asin, 0, __pyx_mstate_global->__pyx_n_u_super_fast_asin, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[80])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1476, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_super_fast_asin, __pyx_t_3) < 0) __PYX_ERR(0, 1476, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1477:     # 29 ns per call when compiled, compared to the math.asin which takes 160 ns

+1478:     x_square = x*x

  __pyx_v_x_square = (__pyx_v_x * __pyx_v_x);

+1479:     return x*(0.9678828 + x_square*(0.8698691 - x_square*(2.166373 - x_square*1.848968)))

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble((__pyx_v_x * (0.9678828 + (__pyx_v_x_square * (0.8698691 - (__pyx_v_x_square * (2.166373 - (__pyx_v_x_square * 1.848968)))))))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1479, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1480: 

 1481: 

+1482: def fast_asin(x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_23fast_asin(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_23fast_asin = {"fast_asin", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_23fast_asin, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_23fast_asin(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fast_asin (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1482, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1482, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "fast_asin", 0) < 0) __PYX_ERR(0, 1482, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("fast_asin", 1, 1, 1, i); __PYX_ERR(0, 1482, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1482, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1482, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("fast_asin", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1482, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.fast_asin", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_22fast_asin(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_22fast_asin(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  double __pyx_v_negate;
  double __pyx_v_ret;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.fast_asin", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1482, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1482, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1482, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_23fast_asin, 0, __pyx_mstate_global->__pyx_n_u_fast_asin, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[81])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1482, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_fast_asin, __pyx_t_4) < 0) __PYX_ERR(0, 1482, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1483:     # 48 ns per call when compiled

+1484:     negate = float(x < 0)

  __pyx_v_negate = ((double)(__pyx_v_x < 0.0));

+1485:     x = abs(x)

  __pyx_t_1 = fabs(__pyx_v_x); 
  __pyx_v_x = __pyx_t_1;

+1486:     ret = (((-0.0187293*x + 0.0742610)*x - 0.2121144)*x + 1.5707288)

  __pyx_v_ret = ((((((-0.0187293 * __pyx_v_x) + 0.0742610) * __pyx_v_x) - 0.2121144) * __pyx_v_x) + 1.5707288);

+1487:     ret = 0.5*pi - sqrt(1.0 - x)*ret

  __pyx_v_ret = ((0.5 * M_PI) - (sqrt((1.0 - __pyx_v_x)) * __pyx_v_ret));

+1488:     return ret - 2.0*negate*ret

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble((__pyx_v_ret - ((2.0 * __pyx_v_negate) * __pyx_v_ret))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1488, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1489: 

 1490: 

+1491: def super_fast_atan2(y: float, x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_25super_fast_atan2(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_25super_fast_atan2 = {"super_fast_atan2", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_25super_fast_atan2, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_25super_fast_atan2(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_y;
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("super_fast_atan2 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_y,&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1491, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1491, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1491, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "super_fast_atan2", 0) < 0) __PYX_ERR(0, 1491, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("super_fast_atan2", 1, 2, 2, i); __PYX_ERR(0, 1491, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1491, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1491, __pyx_L3_error)
    }
    __pyx_v_y = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1491, __pyx_L3_error)
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1491, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("super_fast_atan2", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1491, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.super_fast_atan2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_24super_fast_atan2(__pyx_self, __pyx_v_y, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_24super_fast_atan2(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_y, double __pyx_v_x) {
  int __pyx_v_swap;
  double __pyx_v_atan_input;
  double __pyx_v_x_sq;
  double __pyx_v_atan_result;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.super_fast_atan2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1491, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1491, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1491, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_25super_fast_atan2, 0, __pyx_mstate_global->__pyx_n_u_super_fast_atan2, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[82])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_super_fast_atan2, __pyx_t_3) < 0) __PYX_ERR(0, 1491, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1492:     # Coefficients for the atan approximation

 1493: 

 1494:     # Handle edge cases for 0 inputs

+1495:     if x == 0.0:

  __pyx_t_1 = (__pyx_v_x == 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1496:         if y == 0.0:

    __pyx_t_1 = (__pyx_v_y == 0.0);
    if (__pyx_t_1) {
/* … */
    }

+1497:             return 0.0  # atan2(0, 0) is undefined; returning 0 for simplicity

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
      goto __pyx_L0;

 1498:         else:

+1499:             return 0.5*pi if y > 0.0 else -0.5*pi

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_1 = (__pyx_v_y > 0.0);
      if (__pyx_t_1) {
        __pyx_t_3 = PyFloat_FromDouble((0.5 * M_PI)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_2 = __pyx_t_3;
        __pyx_t_3 = 0;
      } else {
        __pyx_t_3 = PyFloat_FromDouble((-0.5 * M_PI)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_2 = __pyx_t_3;
        __pyx_t_3 = 0;
      }
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;
    }

+1500:     if y == 0.0:

  __pyx_t_1 = (__pyx_v_y == 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1501:         if x > 0.0:

    __pyx_t_1 = (__pyx_v_x > 0.0);
    if (__pyx_t_1) {
/* … */
    }

+1502:             return 0.0

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
      goto __pyx_L0;

 1503:         else:

+1504:             return pi

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_2 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1504, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;
    }

 1505: 

 1506:     # Determine the input for the approximation based on |y| and |x|

+1507:     if abs(x) < abs(y):

  __pyx_t_4 = fabs(__pyx_v_x); 
  __pyx_t_5 = fabs(__pyx_v_y); 
  __pyx_t_1 = (__pyx_t_4 < __pyx_t_5);
  if (__pyx_t_1) {
/* … */
    goto __pyx_L7;
  }

+1508:         swap = True

    __pyx_v_swap = 1;

+1509:         atan_input = x/y

    if (unlikely(__pyx_v_y == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 1509, __pyx_L1_error)
    }
    __pyx_v_atan_input = (__pyx_v_x / __pyx_v_y);

 1510:     else:

+1511:         swap = False

  /*else*/ {
    __pyx_v_swap = 0;

+1512:         atan_input = y/x

    if (unlikely(__pyx_v_x == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 1512, __pyx_L1_error)
    }
    __pyx_v_atan_input = (__pyx_v_y / __pyx_v_x);
  }
  __pyx_L7:;

 1513: 

 1514:     # Calculate the atan approximation

+1515:     x_sq = atan_input*atan_input

  __pyx_v_x_sq = (__pyx_v_atan_input * __pyx_v_atan_input);

+1516:     atan_result = atan_input*(0.995354 - x_sq*(0.288679 - 0.079331*x_sq))

  __pyx_v_atan_result = (__pyx_v_atan_input * (0.995354 - (__pyx_v_x_sq * (0.288679 - (0.079331 * __pyx_v_x_sq)))));

 1517: 

 1518:     # Adjust the result based on the original input quadrant

+1519:     if swap:

  if (__pyx_v_swap) {
/* … */
  }

+1520:         if atan_input >= 0.0:

    __pyx_t_1 = (__pyx_v_atan_input >= 0.0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L9;
    }

+1521:             atan_result = 0.5*pi - atan_result

      __pyx_v_atan_result = ((0.5 * M_PI) - __pyx_v_atan_result);

 1522:         else:

+1523:             atan_result = -0.5*pi - atan_result

    /*else*/ {
      __pyx_v_atan_result = ((-0.5 * M_PI) - __pyx_v_atan_result);
    }
    __pyx_L9:;

 1524: 

 1525:     # Adjust for the correct quadrant

+1526:     if x < 0.0:

  __pyx_t_1 = (__pyx_v_x < 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1527:         if y >= 0.0:

    __pyx_t_1 = (__pyx_v_y >= 0.0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L11;
    }

+1528:             atan_result += pi

      __pyx_v_atan_result = (__pyx_v_atan_result + M_PI);

 1529:         else:

+1530:             atan_result += -pi

    /*else*/ {
      __pyx_v_atan_result = (__pyx_v_atan_result + (-M_PI));
    }
    __pyx_L11:;

 1531: 

+1532:     return atan_result

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_atan_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1532, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1533: 

 1534: 

+1535: def fast_atan2(y: float, x: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_27fast_atan2(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_27fast_atan2 = {"fast_atan2", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_27fast_atan2, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_27fast_atan2(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_y;
  double __pyx_v_x;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fast_atan2 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_y,&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1535, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1535, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1535, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "fast_atan2", 0) < 0) __PYX_ERR(0, 1535, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("fast_atan2", 1, 2, 2, i); __PYX_ERR(0, 1535, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1535, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1535, __pyx_L3_error)
    }
    __pyx_v_y = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1535, __pyx_L3_error)
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1535, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("fast_atan2", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1535, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.fast_atan2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_26fast_atan2(__pyx_self, __pyx_v_y, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_26fast_atan2(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_y, double __pyx_v_x) {
  int __pyx_v_swap;
  double __pyx_v_atan_input;
  double __pyx_v_x_sq;
  double __pyx_v_atan_result;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.fast_atan2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1535, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1535, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1535, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1535, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_27fast_atan2, 0, __pyx_mstate_global->__pyx_n_u_fast_atan2, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[83])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1535, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_fast_atan2, __pyx_t_4) < 0) __PYX_ERR(0, 1535, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1536:     # Coefficients for the atan approximation

 1537: 

 1538:     # Handle edge cases for 0 inputs

+1539:     if x == 0.0:

  __pyx_t_1 = (__pyx_v_x == 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1540:         if y == 0.0:

    __pyx_t_1 = (__pyx_v_y == 0.0);
    if (__pyx_t_1) {
/* … */
    }

+1541:             return 0.0  # atan2(0, 0) is undefined; returning 0 for simplicity

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
      goto __pyx_L0;

 1542:         else:

+1543:             return 0.5*pi if y > 0.0 else -0.5*pi

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_1 = (__pyx_v_y > 0.0);
      if (__pyx_t_1) {
        __pyx_t_3 = PyFloat_FromDouble((0.5 * M_PI)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1543, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_2 = __pyx_t_3;
        __pyx_t_3 = 0;
      } else {
        __pyx_t_3 = PyFloat_FromDouble((-0.5 * M_PI)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1543, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_2 = __pyx_t_3;
        __pyx_t_3 = 0;
      }
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;
    }

+1544:     if y == 0.0:

  __pyx_t_1 = (__pyx_v_y == 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1545:         if x > 0.0:

    __pyx_t_1 = (__pyx_v_x > 0.0);
    if (__pyx_t_1) {
/* … */
    }

+1546:             return 0.0

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
      goto __pyx_L0;

 1547:         else:

+1548:             return pi

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_2 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1548, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;
    }

 1549: 

 1550:     # Determine the input for the approximation based on |y| and |x|

+1551:     if abs(x) < abs(y):

  __pyx_t_4 = fabs(__pyx_v_x); 
  __pyx_t_5 = fabs(__pyx_v_y); 
  __pyx_t_1 = (__pyx_t_4 < __pyx_t_5);
  if (__pyx_t_1) {
/* … */
    goto __pyx_L7;
  }

+1552:         swap = True

    __pyx_v_swap = 1;

+1553:         atan_input = x/y

    if (unlikely(__pyx_v_y == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 1553, __pyx_L1_error)
    }
    __pyx_v_atan_input = (__pyx_v_x / __pyx_v_y);

 1554:     else:

+1555:         swap = False

  /*else*/ {
    __pyx_v_swap = 0;

+1556:         atan_input = y/x

    if (unlikely(__pyx_v_x == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 1556, __pyx_L1_error)
    }
    __pyx_v_atan_input = (__pyx_v_y / __pyx_v_x);
  }
  __pyx_L7:;

 1557: 

 1558:     # Calculate the atan approximation

+1559:     x_sq = atan_input*atan_input

  __pyx_v_x_sq = (__pyx_v_atan_input * __pyx_v_atan_input);

+1560:     atan_result = atan_input*(0.99997726 - x_sq*(0.33262347 - x_sq*(0.19354346 - x_sq*(0.11643287 - x_sq*(0.05265332 - x_sq*0.01172120)))))

  __pyx_v_atan_result = (__pyx_v_atan_input * (0.99997726 - (__pyx_v_x_sq * (0.33262347 - (__pyx_v_x_sq * (0.19354346 - (__pyx_v_x_sq * (0.11643287 - (__pyx_v_x_sq * (0.05265332 - (__pyx_v_x_sq * 0.01172120)))))))))));

 1561: 

 1562:     # Adjust the result based on the original input quadrant

+1563:     if swap:

  if (__pyx_v_swap) {
/* … */
  }

+1564:         if atan_input >= 0.0:

    __pyx_t_1 = (__pyx_v_atan_input >= 0.0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L9;
    }

+1565:             atan_result = 0.5*pi - atan_result

      __pyx_v_atan_result = ((0.5 * M_PI) - __pyx_v_atan_result);

 1566:         else:

+1567:             atan_result = -0.5*pi - atan_result

    /*else*/ {
      __pyx_v_atan_result = ((-0.5 * M_PI) - __pyx_v_atan_result);
    }
    __pyx_L9:;

 1568: 

 1569:     # Adjust for the correct quadrant

+1570:     if x < 0.0:

  __pyx_t_1 = (__pyx_v_x < 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1571:         if y >= 0.0:

    __pyx_t_1 = (__pyx_v_y >= 0.0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L11;
    }

+1572:             atan_result += pi

      __pyx_v_atan_result = (__pyx_v_atan_result + M_PI);

 1573:         else:

+1574:             atan_result += -pi

    /*else*/ {
      __pyx_v_atan_result = (__pyx_v_atan_result + (-M_PI));
    }
    __pyx_L11:;

 1575: 

+1576:     return atan_result

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_atan_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1577: 

 1578: 

+1579: def heading_diff_within_threshold(a_vec_theta_rad: float, b_vec_x: float, b_vec_y: float, cos_threshold: float) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_29heading_diff_within_threshold(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_28heading_diff_within_threshold, "a and b are direction vectors. This checks whether the absolute heading difference between them are within a threshold angle.");
static PyMethodDef __pyx_mdef_14neo_controller_29heading_diff_within_threshold = {"heading_diff_within_threshold", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_29heading_diff_within_threshold, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_28heading_diff_within_threshold};
static PyObject *__pyx_pw_14neo_controller_29heading_diff_within_threshold(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_a_vec_theta_rad;
  double __pyx_v_b_vec_x;
  double __pyx_v_b_vec_y;
  double __pyx_v_cos_threshold;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("heading_diff_within_threshold (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_a_vec_theta_rad,&__pyx_mstate_global->__pyx_n_u_b_vec_x,&__pyx_mstate_global->__pyx_n_u_b_vec_y,&__pyx_mstate_global->__pyx_n_u_cos_threshold,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1579, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1579, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1579, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1579, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1579, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "heading_diff_within_threshold", 0) < 0) __PYX_ERR(0, 1579, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("heading_diff_within_threshold", 1, 4, 4, i); __PYX_ERR(0, 1579, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1579, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1579, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1579, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1579, __pyx_L3_error)
    }
    __pyx_v_a_vec_theta_rad = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_a_vec_theta_rad == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L3_error)
    __pyx_v_b_vec_x = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_b_vec_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L3_error)
    __pyx_v_b_vec_y = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_b_vec_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L3_error)
    __pyx_v_cos_threshold = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_cos_threshold == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("heading_diff_within_threshold", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 1579, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.heading_diff_within_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_28heading_diff_within_threshold(__pyx_self, __pyx_v_a_vec_theta_rad, __pyx_v_b_vec_x, __pyx_v_b_vec_y, __pyx_v_cos_threshold);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_28heading_diff_within_threshold(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_a_vec_theta_rad, double __pyx_v_b_vec_x, double __pyx_v_b_vec_y, double __pyx_v_cos_threshold) {
  double __pyx_v_a_vec_x;
  double __pyx_v_a_vec_y;
  double __pyx_v_dot_product;
  double __pyx_v_magnitude;
  double __pyx_v_cos_theta;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.heading_diff_within_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1579, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a_vec_theta_rad, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1579, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_b_vec_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1579, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_b_vec_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1579, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_cos_threshold, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1579, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1579, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_29heading_diff_within_threshold, 0, __pyx_mstate_global->__pyx_n_u_heading_diff_within_threshold, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[84])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1579, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_heading_diff_within_threshold, __pyx_t_3) < 0) __PYX_ERR(0, 1579, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1580:     '''a and b are direction vectors. This checks whether the absolute heading difference between them are within a threshold angle.'''

 1581:     # This function would work the same way as if we took the ship's heading, and found the absolute wrapped difference between that and the direction vector of the asteroid, and then compared against the threshold

 1582:     # But this method is faster as it avoids the atan2 calculation, and instead does a sin and cos and does the threshold comparison with the cos value of the angle, instead of the angle itself

 1583:     # The old method is shown below for reference:

 1584:     # theta = degrees(atan2(b_vec_y, b_vec_x))

 1585:     # threshold_angle = acos(cos_threshold)

 1586:     # return abs(angle_difference_deg(theta, degrees(a_vec_theta_rad))) <= degrees(threshold_angle)

 1587: 

 1588:     #a_vec_norm = 1.0

+1589:     a_vec_x = cos(a_vec_theta_rad)

  __pyx_v_a_vec_x = cos(__pyx_v_a_vec_theta_rad);

+1590:     a_vec_y = sin(a_vec_theta_rad)

  __pyx_v_a_vec_y = sin(__pyx_v_a_vec_theta_rad);

+1591:     dot_product = a_vec_x*b_vec_x + a_vec_y*b_vec_y

  __pyx_v_dot_product = ((__pyx_v_a_vec_x * __pyx_v_b_vec_x) + (__pyx_v_a_vec_y * __pyx_v_b_vec_y));

+1592:     magnitude = sqrt(b_vec_x*b_vec_x + b_vec_y*b_vec_y)

  __pyx_v_magnitude = sqrt(((__pyx_v_b_vec_x * __pyx_v_b_vec_x) + (__pyx_v_b_vec_y * __pyx_v_b_vec_y)));

+1593:     if magnitude != 0:

  __pyx_t_1 = (__pyx_v_magnitude != 0.0);
  if (__pyx_t_1) {
/* … */
  }

+1594:         cos_theta = dot_product/magnitude # a_vec_norm is 1.0 since it's a unit vector, so we don't need to multiply by that

    if (unlikely(__pyx_v_magnitude == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 1594, __pyx_L1_error)
    }
    __pyx_v_cos_theta = (__pyx_v_dot_product / __pyx_v_magnitude);

+1595:         return cos_theta >= cos_threshold

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_v_cos_theta >= __pyx_v_cos_threshold)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1595, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

 1596:     else:

+1597:         return True

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;
  }

 1598: 

 1599: 

+1600: @lru_cache

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_31get_min_respawn_per_timestep_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_31get_min_respawn_per_timestep_search_iterations = {"get_min_respawn_per_timestep_search_iterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_31get_min_respawn_per_timestep_search_iterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_31get_min_respawn_per_timestep_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_lives = 0;
  double __pyx_v_average_fitness;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_min_respawn_per_timestep_search_iterations (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_lives,&__pyx_mstate_global->__pyx_n_u_average_fitness,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1600, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1600, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1600, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_min_respawn_per_timestep_search_iterations", 0) < 0) __PYX_ERR(0, 1600, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_min_respawn_per_timestep_search_iterations", 1, 2, 2, i); __PYX_ERR(0, 1600, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1600, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1600, __pyx_L3_error)
    }
    __pyx_v_lives = ((PyObject*)values[0]);
    __pyx_v_average_fitness = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_average_fitness == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1601, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_min_respawn_per_timestep_search_iterations", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1600, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_min_respawn_per_timestep_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lives), (&PyLong_Type), 0, "lives", 2))) __PYX_ERR(0, 1601, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_30get_min_respawn_per_timestep_search_iterations(__pyx_self, __pyx_v_lives, __pyx_v_average_fitness);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_30get_min_respawn_per_timestep_search_iterations(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_lives, double __pyx_v_average_fitness) {
  PyObject *__pyx_v_lives_lookup_index = NULL;
  PyObject *__pyx_v_fitness_lookup_index = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_min_respawn_per_timestep_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_lives_lookup_index);
  __Pyx_XDECREF(__pyx_v_fitness_lookup_index);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lives, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1600, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_average_fitness, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1600, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1600, __pyx_L1_error)
  __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_31get_min_respawn_per_timestep_search_iterations, 0, __pyx_mstate_global->__pyx_n_u_get_min_respawn_per_timestep_sea, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[85])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_10, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_10};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1600, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_min_respawn_per_timestep_sea, __pyx_t_3) < 0) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1601: def get_min_respawn_per_timestep_search_iterations(lives: int, average_fitness: float) -> int:

+1602:     assert 0.0 <= average_fitness < 1.0

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = (0.0 <= __pyx_v_average_fitness);
    if (__pyx_t_1) {
      __pyx_t_1 = (__pyx_v_average_fitness < 1.0);
    }
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 1602, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 1602, __pyx_L1_error)
  #endif

+1603:     lives_lookup_index = min(3, lives)

  __Pyx_INCREF(__pyx_v_lives);
  __pyx_t_2 = __pyx_v_lives;
  __pyx_t_3 = 3;
  __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1603, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1603, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = __pyx_t_2;
  } else {
    __pyx_t_6 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1603, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (!(likely(PyLong_CheckExact(__pyx_t_6)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 1603, __pyx_L1_error)
    __pyx_t_4 = __pyx_t_6;
    __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_lives_lookup_index = ((PyObject*)__pyx_t_6);
  __pyx_t_6 = 0;

+1604:     fitness_lookup_index = floor(average_fitness*10.0) # Integer from 0 to 9

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1604, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = PyFloat_FromDouble((__pyx_v_average_fitness * 10.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1604, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1604, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_fitness_lookup_index = __pyx_t_6;
  __pyx_t_6 = 0;

+1605:     return MIN_RESPAWN_PER_TIMESTEP_SEARCH_ITERATIONS_LUT[fitness_lookup_index][lives_lookup_index - 1]

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MIN_RESPAWN_PER_TIMESTEP_SEARCH); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_6, __pyx_v_fitness_lookup_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyLong_SubtractObjC(__pyx_v_lives_lookup_index, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_7))) __PYX_ERR(0, 1605, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;
  goto __pyx_L0;

 1606: 

 1607: 

+1608: @lru_cache

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_33get_min_respawn_per_period_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_33get_min_respawn_per_period_search_iterations = {"get_min_respawn_per_period_search_iterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_33get_min_respawn_per_period_search_iterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_33get_min_respawn_per_period_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_lives = 0;
  double __pyx_v_average_fitness;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_min_respawn_per_period_search_iterations (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_lives,&__pyx_mstate_global->__pyx_n_u_average_fitness,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1608, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1608, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1608, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_min_respawn_per_period_search_iterations", 0) < 0) __PYX_ERR(0, 1608, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_min_respawn_per_period_search_iterations", 1, 2, 2, i); __PYX_ERR(0, 1608, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1608, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1608, __pyx_L3_error)
    }
    __pyx_v_lives = ((PyObject*)values[0]);
    __pyx_v_average_fitness = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_average_fitness == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1609, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_min_respawn_per_period_search_iterations", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1608, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_min_respawn_per_period_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lives), (&PyLong_Type), 0, "lives", 2))) __PYX_ERR(0, 1609, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_32get_min_respawn_per_period_search_iterations(__pyx_self, __pyx_v_lives, __pyx_v_average_fitness);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_32get_min_respawn_per_period_search_iterations(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_lives, double __pyx_v_average_fitness) {
  PyObject *__pyx_v_lives_lookup_index = NULL;
  PyObject *__pyx_v_fitness_lookup_index = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_min_respawn_per_period_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_lives_lookup_index);
  __Pyx_XDECREF(__pyx_v_fitness_lookup_index);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_lives, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1608, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_average_fitness, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1608, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1608, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_33get_min_respawn_per_period_search_iterations, 0, __pyx_mstate_global->__pyx_n_u_get_min_respawn_per_period_searc, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[86])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1608, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_min_respawn_per_period_searc, __pyx_t_3) < 0) __PYX_ERR(0, 1608, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1609: def get_min_respawn_per_period_search_iterations(lives: int, average_fitness: float) -> int:

+1610:     assert 0.0 <= average_fitness < 1.0

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = (0.0 <= __pyx_v_average_fitness);
    if (__pyx_t_1) {
      __pyx_t_1 = (__pyx_v_average_fitness < 1.0);
    }
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 1610, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 1610, __pyx_L1_error)
  #endif

+1611:     lives_lookup_index = min(3, lives)

  __Pyx_INCREF(__pyx_v_lives);
  __pyx_t_2 = __pyx_v_lives;
  __pyx_t_3 = 3;
  __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1611, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1611, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1611, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = __pyx_t_2;
  } else {
    __pyx_t_6 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1611, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (!(likely(PyLong_CheckExact(__pyx_t_6)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 1611, __pyx_L1_error)
    __pyx_t_4 = __pyx_t_6;
    __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_lives_lookup_index = ((PyObject*)__pyx_t_6);
  __pyx_t_6 = 0;

+1612:     fitness_lookup_index = floor(average_fitness*10.0) # Integer from 0 to 9

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1612, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = PyFloat_FromDouble((__pyx_v_average_fitness * 10.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1612, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1612, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_fitness_lookup_index = __pyx_t_6;
  __pyx_t_6 = 0;

+1613:     return MIN_RESPAWN_PER_PERIOD_SEARCH_ITERATIONS_LUT[fitness_lookup_index][lives_lookup_index - 1]

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MIN_RESPAWN_PER_PERIOD_SEARCH_IT); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_6, __pyx_v_fitness_lookup_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyLong_SubtractObjC(__pyx_v_lives_lookup_index, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_7))) __PYX_ERR(0, 1613, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;
  goto __pyx_L0;

 1614: 

 1615: 

+1616: @lru_cache

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_35get_min_maneuver_per_timestep_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_35get_min_maneuver_per_timestep_search_iterations = {"get_min_maneuver_per_timestep_search_iterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_35get_min_maneuver_per_timestep_search_iterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_35get_min_maneuver_per_timestep_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_lives = 0;
  double __pyx_v_average_fitness;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_min_maneuver_per_timestep_search_iterations (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_lives,&__pyx_mstate_global->__pyx_n_u_average_fitness,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1616, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1616, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1616, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_min_maneuver_per_timestep_search_iterations", 0) < 0) __PYX_ERR(0, 1616, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_min_maneuver_per_timestep_search_iterations", 1, 2, 2, i); __PYX_ERR(0, 1616, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1616, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1616, __pyx_L3_error)
    }
    __pyx_v_lives = ((PyObject*)values[0]);
    __pyx_v_average_fitness = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_average_fitness == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1617, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_min_maneuver_per_timestep_search_iterations", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1616, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_min_maneuver_per_timestep_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lives), (&PyLong_Type), 0, "lives", 2))) __PYX_ERR(0, 1617, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_34get_min_maneuver_per_timestep_search_iterations(__pyx_self, __pyx_v_lives, __pyx_v_average_fitness);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_34get_min_maneuver_per_timestep_search_iterations(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_lives, double __pyx_v_average_fitness) {
  PyObject *__pyx_v_lives_lookup_index = NULL;
  PyObject *__pyx_v_fitness_lookup_index = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_min_maneuver_per_timestep_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_lives_lookup_index);
  __Pyx_XDECREF(__pyx_v_fitness_lookup_index);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_lives, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1616, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_average_fitness, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1616, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1616, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_35get_min_maneuver_per_timestep_search_iterations, 0, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_timestep_se, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_4};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1616, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_timestep_se, __pyx_t_3) < 0) __PYX_ERR(0, 1616, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1617: def get_min_maneuver_per_timestep_search_iterations(lives: int, average_fitness: float) -> int:

+1618:     assert 0.0 <= average_fitness < 1.0

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = (0.0 <= __pyx_v_average_fitness);
    if (__pyx_t_1) {
      __pyx_t_1 = (__pyx_v_average_fitness < 1.0);
    }
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 1618, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 1618, __pyx_L1_error)
  #endif

+1619:     lives_lookup_index = min(3, lives)

  __Pyx_INCREF(__pyx_v_lives);
  __pyx_t_2 = __pyx_v_lives;
  __pyx_t_3 = 3;
  __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1619, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1619, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1619, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = __pyx_t_2;
  } else {
    __pyx_t_6 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1619, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (!(likely(PyLong_CheckExact(__pyx_t_6)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 1619, __pyx_L1_error)
    __pyx_t_4 = __pyx_t_6;
    __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_lives_lookup_index = ((PyObject*)__pyx_t_6);
  __pyx_t_6 = 0;

+1620:     fitness_lookup_index = floor(average_fitness*10.0) # Integer from 0 to 9

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1620, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = PyFloat_FromDouble((__pyx_v_average_fitness * 10.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1620, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1620, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_fitness_lookup_index = __pyx_t_6;
  __pyx_t_6 = 0;

+1621:     return MIN_MANEUVER_PER_TIMESTEP_SEARCH_ITERATIONS_LUT[fitness_lookup_index][lives_lookup_index - 1]

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MIN_MANEUVER_PER_TIMESTEP_SEARCH); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_6, __pyx_v_fitness_lookup_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyLong_SubtractObjC(__pyx_v_lives_lookup_index, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_7))) __PYX_ERR(0, 1621, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;
  goto __pyx_L0;

 1622: 

 1623: 

+1624: @lru_cache

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_37get_min_maneuver_per_period_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_37get_min_maneuver_per_period_search_iterations = {"get_min_maneuver_per_period_search_iterations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_37get_min_maneuver_per_period_search_iterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_37get_min_maneuver_per_period_search_iterations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_lives = 0;
  double __pyx_v_average_fitness;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_min_maneuver_per_period_search_iterations (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_lives,&__pyx_mstate_global->__pyx_n_u_average_fitness,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1624, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1624, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1624, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_min_maneuver_per_period_search_iterations", 0) < 0) __PYX_ERR(0, 1624, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_min_maneuver_per_period_search_iterations", 1, 2, 2, i); __PYX_ERR(0, 1624, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1624, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1624, __pyx_L3_error)
    }
    __pyx_v_lives = ((PyObject*)values[0]);
    __pyx_v_average_fitness = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_average_fitness == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1625, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_min_maneuver_per_period_search_iterations", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1624, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_min_maneuver_per_period_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lives), (&PyLong_Type), 0, "lives", 2))) __PYX_ERR(0, 1625, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_36get_min_maneuver_per_period_search_iterations(__pyx_self, __pyx_v_lives, __pyx_v_average_fitness);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_36get_min_maneuver_per_period_search_iterations(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_lives, double __pyx_v_average_fitness) {
  PyObject *__pyx_v_lives_lookup_index = NULL;
  PyObject *__pyx_v_fitness_lookup_index = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_min_maneuver_per_period_search_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_lives_lookup_index);
  __Pyx_XDECREF(__pyx_v_fitness_lookup_index);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_lives, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1624, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_average_fitness, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1624, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1624, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_37get_min_maneuver_per_period_search_iterations, 0, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear_2, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_10);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_2};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1624, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear_2, __pyx_t_3) < 0) __PYX_ERR(0, 1624, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1625: def get_min_maneuver_per_period_search_iterations(lives: int, average_fitness: float) -> int:

+1626:     assert 0.0 <= average_fitness < 1.0

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = (0.0 <= __pyx_v_average_fitness);
    if (__pyx_t_1) {
      __pyx_t_1 = (__pyx_v_average_fitness < 1.0);
    }
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 1626, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 1626, __pyx_L1_error)
  #endif

+1627:     lives_lookup_index = min(3, lives)

  __Pyx_INCREF(__pyx_v_lives);
  __pyx_t_2 = __pyx_v_lives;
  __pyx_t_3 = 3;
  __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1627, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1627, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1627, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = __pyx_t_2;
  } else {
    __pyx_t_6 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (!(likely(PyLong_CheckExact(__pyx_t_6)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 1627, __pyx_L1_error)
    __pyx_t_4 = __pyx_t_6;
    __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_lives_lookup_index = ((PyObject*)__pyx_t_6);
  __pyx_t_6 = 0;

+1628:     fitness_lookup_index = floor(average_fitness*10.0) # Integer from 0 to 9

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = PyFloat_FromDouble((__pyx_v_average_fitness * 10.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1628, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_fitness_lookup_index = __pyx_t_6;
  __pyx_t_6 = 0;

+1629:     return MIN_MANEUVER_PER_PERIOD_SEARCH_ITERATIONS_LUT[fitness_lookup_index][lives_lookup_index - 1]

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MIN_MANEUVER_PER_PERIOD_SEARCH_I); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1629, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_6, __pyx_v_fitness_lookup_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1629, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyLong_SubtractObjC(__pyx_v_lives_lookup_index, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1629, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1629, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_7))) __PYX_ERR(0, 1629, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;
  goto __pyx_L0;

 1630: 

 1631: 

+1632: @lru_cache

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_39get_min_maneuver_per_period_search_iterations_if_will_die(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_39get_min_maneuver_per_period_search_iterations_if_will_die = {"get_min_maneuver_per_period_search_iterations_if_will_die", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_39get_min_maneuver_per_period_search_iterations_if_will_die, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_39get_min_maneuver_per_period_search_iterations_if_will_die(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_lives = 0;
  double __pyx_v_average_fitness;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_min_maneuver_per_period_search_iterations_if_will_die (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_lives,&__pyx_mstate_global->__pyx_n_u_average_fitness,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1632, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1632, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1632, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_min_maneuver_per_period_search_iterations_if_will_die", 0) < 0) __PYX_ERR(0, 1632, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_min_maneuver_per_period_search_iterations_if_will_die", 1, 2, 2, i); __PYX_ERR(0, 1632, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1632, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1632, __pyx_L3_error)
    }
    __pyx_v_lives = ((PyObject*)values[0]);
    __pyx_v_average_fitness = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_average_fitness == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1633, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_min_maneuver_per_period_search_iterations_if_will_die", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1632, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_min_maneuver_per_period_search_iterations_if_will_die", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lives), (&PyLong_Type), 0, "lives", 2))) __PYX_ERR(0, 1633, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_38get_min_maneuver_per_period_search_iterations_if_will_die(__pyx_self, __pyx_v_lives, __pyx_v_average_fitness);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_38get_min_maneuver_per_period_search_iterations_if_will_die(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_lives, double __pyx_v_average_fitness) {
  PyObject *__pyx_v_lives_lookup_index = NULL;
  PyObject *__pyx_v_fitness_lookup_index = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_min_maneuver_per_period_search_iterations_if_will_die", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_lives_lookup_index);
  __Pyx_XDECREF(__pyx_v_fitness_lookup_index);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lives, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1632, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_average_fitness, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1632, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1632, __pyx_L1_error)
  __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_39get_min_maneuver_per_period_search_iterations_if_will_die, 0, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[89])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_10, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_10};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1632, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear, __pyx_t_3) < 0) __PYX_ERR(0, 1632, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1633: def get_min_maneuver_per_period_search_iterations_if_will_die(lives: int, average_fitness: float) -> int:

 1634:     # If we plan to die, we might as well search a bunch more iterations to try and avoid the death.

 1635:     # Because if we die, we need to do an expensive respawn maneuver search anyway, so it's more optimal to try and avoid that.

+1636:     assert 0.0 <= average_fitness < 1.0

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = (0.0 <= __pyx_v_average_fitness);
    if (__pyx_t_1) {
      __pyx_t_1 = (__pyx_v_average_fitness < 1.0);
    }
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 1636, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 1636, __pyx_L1_error)
  #endif

+1637:     lives_lookup_index = min(3, lives)

  __Pyx_INCREF(__pyx_v_lives);
  __pyx_t_2 = __pyx_v_lives;
  __pyx_t_3 = 3;
  __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1637, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1637, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = __pyx_t_2;
  } else {
    __pyx_t_6 = __Pyx_PyLong_From_long(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1637, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (!(likely(PyLong_CheckExact(__pyx_t_6)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 1637, __pyx_L1_error)
    __pyx_t_4 = __pyx_t_6;
    __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_lives_lookup_index = ((PyObject*)__pyx_t_6);
  __pyx_t_6 = 0;

+1638:     fitness_lookup_index = floor(average_fitness*10.0) # Integer from 0 to 9

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1638, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = PyFloat_FromDouble((__pyx_v_average_fitness * 10.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1638, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1638, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_fitness_lookup_index = __pyx_t_6;
  __pyx_t_6 = 0;

+1639:     return MIN_MANEUVER_PER_PERIOD_SEARCH_ITERATIONS_IF_WILL_DIE_LUT[fitness_lookup_index][lives_lookup_index - 1]

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MIN_MANEUVER_PER_PERIOD_SEARCH_I_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1639, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_6, __pyx_v_fitness_lookup_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1639, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyLong_SubtractObjC(__pyx_v_lives_lookup_index, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1639, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1639, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_7))) __PYX_ERR(0, 1639, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;
  goto __pyx_L0;

 1640: 

 1641: 

+1642: @lru_cache()

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_41set_up_mine_fis(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_41set_up_mine_fis = {"set_up_mine_fis", (PyCFunction)__pyx_pw_14neo_controller_41set_up_mine_fis, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_41set_up_mine_fis(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("set_up_mine_fis (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_40set_up_mine_fis(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_40set_up_mine_fis(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_v_mines_left = NULL;
  PyObject *__pyx_v_lives_left = NULL;
  PyObject *__pyx_v_asteroids_hit = NULL;
  PyObject *__pyx_v_drop_mine = NULL;
  PyObject *__pyx_v_rules = NULL;
  PyObject *__pyx_v_mine_dropping_control = NULL;
  PyObject *__pyx_v_mine_dropping_fis = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_AddTraceback("neo_controller.set_up_mine_fis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mines_left);
  __Pyx_XDECREF(__pyx_v_lives_left);
  __Pyx_XDECREF(__pyx_v_asteroids_hit);
  __Pyx_XDECREF(__pyx_v_drop_mine);
  __Pyx_XDECREF(__pyx_v_rules);
  __Pyx_XDECREF(__pyx_v_mine_dropping_control);
  __Pyx_XDECREF(__pyx_v_mine_dropping_fis);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = NULL;
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1642, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_control_ControlSystemSimulation) < 0) __PYX_ERR(0, 1642, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_41set_up_mine_fis, 0, __pyx_mstate_global->__pyx_n_u_set_up_mine_fis, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[90])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1642, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_set_up_mine_fis, __pyx_t_3) < 0) __PYX_ERR(0, 1642, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1643: def set_up_mine_fis() -> control.ControlSystemSimulation:

 1644:     # set up mine FIS

+1645:     mines_left = control.Antecedent(arange(0, 4, 1), 'mines_left')

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1645, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1645, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1645, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[1], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1645, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_mines_left};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1645, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_mines_left = __pyx_t_1;
  __pyx_t_1 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 1645, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]);

+1646:     lives_left = control.Antecedent(arange(1, 4, 1), 'lives_left')

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[2], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_lives_left};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1646, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_lives_left = __pyx_t_1;
  __pyx_t_1 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 1646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]);

+1647:     asteroids_hit = control.Antecedent(arange(0, 51, 1), 'asteroids_hit')

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[3], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_asteroids_hit};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1647, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_asteroids_hit = __pyx_t_1;
  __pyx_t_1 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_51, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 1647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]);

+1648:     drop_mine = control.Consequent(arange(0, 11, 1), 'drop_mine')

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1648, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Consequent); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1648, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1648, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[4], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1648, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_drop_mine};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1648, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_drop_mine = __pyx_t_1;
  __pyx_t_1 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_11, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(0, 1648, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]);

 1649: 

 1650:     # Defining the membership functions

+1651:     mines_left['few'] = trimf(mines_left.universe, [1, 1, 3])

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1651, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1651, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyList_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1651, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1651, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1651, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 1651, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_4, __pyx_t_5};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1651, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_few, __pyx_t_1) < 0))) __PYX_ERR(0, 1651, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1652:     mines_left['many'] = trimf(mines_left.universe, [1.5, 3, 3])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1652, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1652, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1652, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_5);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_1_5);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_float_1_5) != (0)) __PYX_ERR(0, 1652, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 1652, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 2, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 1652, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_4, __pyx_t_2};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1652, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_many, __pyx_t_1) < 0))) __PYX_ERR(0, 1652, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1653:     lives_left['few'] = trimf(lives_left.universe, [1, 1, 2])

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1653, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1653, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyList_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1653, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1653, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1653, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 1653, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_4, __pyx_t_3};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1653, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_few, __pyx_t_1) < 0))) __PYX_ERR(0, 1653, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1654:     lives_left['many'] = trimf(lives_left.universe, [1.5, 3, 3])

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1654, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1654, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyList_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1654, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_5);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_1_5);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_float_1_5) != (0)) __PYX_ERR(0, 1654, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 1654, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 1654, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_4, __pyx_t_5};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1654, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_many, __pyx_t_1) < 0))) __PYX_ERR(0, 1654, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1655:     asteroids_hit['few'] = trimf(asteroids_hit.universe, [0, 0, ASTEROIDS_HIT_OKAY_CENTER])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1655, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1655, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_OKAY_CENTER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1655, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1655, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1655, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1655, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_2) != (0)) __PYX_ERR(0, 1655, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_4, __pyx_t_7};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1655, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_few, __pyx_t_1) < 0))) __PYX_ERR(0, 1655, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1656:     asteroids_hit['okay'] = trimf(asteroids_hit.universe, [0, ASTEROIDS_HIT_OKAY_CENTER, ASTEROIDS_HIT_VERY_GOOD])

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1656, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1656, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_OKAY_CENTER); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1656, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_VERY_GOOD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1656, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1656, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1656, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 1656, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_2) != (0)) __PYX_ERR(0, 1656, __pyx_L1_error);
  __pyx_t_3 = 0;
  __pyx_t_2 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_4, __pyx_t_8};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1656, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_okay, __pyx_t_1) < 0))) __PYX_ERR(0, 1656, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1657:     asteroids_hit['many'] = trimf(asteroids_hit.universe, [ASTEROIDS_HIT_OKAY_CENTER, ASTEROIDS_HIT_VERY_GOOD, ASTEROIDS_HIT_VERY_GOOD])

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_OKAY_CENTER); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_VERY_GOOD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_VERY_GOOD); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_9 = PyList_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1657, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1657, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 1657, __pyx_L1_error);
  __pyx_t_5 = 0;
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_4, __pyx_t_9};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1657, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_many, __pyx_t_1) < 0))) __PYX_ERR(0, 1657, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1658: 

+1659:     drop_mine['no'] = trimf(drop_mine.universe, [0, 0, 5])

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1659, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1659, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1659, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1659, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1659, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_5);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_5);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_5) != (0)) __PYX_ERR(0, 1659, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_4, __pyx_t_7};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1659, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_no, __pyx_t_1) < 0))) __PYX_ERR(0, 1659, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1660:     drop_mine['yes'] = trimf(drop_mine.universe, [5, 10, 10])

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1660, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1660, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1660, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_5);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_5);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_5) != (0)) __PYX_ERR(0, 1660, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_10);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_10);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_mstate_global->__pyx_int_10) != (0)) __PYX_ERR(0, 1660, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_10);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_10);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_10) != (0)) __PYX_ERR(0, 1660, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_4, __pyx_t_8};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1660, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes, __pyx_t_1) < 0))) __PYX_ERR(0, 1660, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1661: 

 1662:     rules = (

+1663:         control.Rule(mines_left['few'] & lives_left['few'] & asteroids_hit['few'], drop_mine['no']),

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_3 = PyNumber_And(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_8 = PyNumber_And(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_no); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_8, __pyx_t_9};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1663, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
/* … */
  __pyx_t_15 = PyTuple_New(12); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 3, __pyx_t_9) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 4, __pyx_t_3) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 5, __pyx_t_2) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 6, __pyx_t_5) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_10);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 7, __pyx_t_10) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_11);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 8, __pyx_t_11) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 9, __pyx_t_12) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 10, __pyx_t_13) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_14);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 11, __pyx_t_14) != (0)) __PYX_ERR(0, 1663, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_t_7 = 0;
  __pyx_t_9 = 0;
  __pyx_t_3 = 0;
  __pyx_t_2 = 0;
  __pyx_t_5 = 0;
  __pyx_t_10 = 0;
  __pyx_t_11 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_14 = 0;
  __pyx_v_rules = ((PyObject*)__pyx_t_15);
  __pyx_t_15 = 0;

+1664:         control.Rule(mines_left['few'] & lives_left['few'] & asteroids_hit['okay'], drop_mine['no']),

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyNumber_And(__pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_okay); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_8 = PyNumber_And(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_no); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_3};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1664, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }

+1665:         control.Rule(mines_left['few'] & lives_left['few'] & asteroids_hit['many'], drop_mine['yes']),

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyNumber_And(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_8 = PyNumber_And(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_8, __pyx_t_2};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1665, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }

+1666:         control.Rule(mines_left['few'] & lives_left['many'] & asteroids_hit['few'], drop_mine['no']),

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_10 = PyNumber_And(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = PyNumber_And(__pyx_t_10, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_no); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_8, __pyx_t_5};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1666, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }

+1667:         control.Rule(mines_left['few'] & lives_left['many'] & asteroids_hit['okay'], drop_mine['yes']),

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_11 = PyNumber_And(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_okay); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_8 = PyNumber_And(__pyx_t_11, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_8, __pyx_t_10};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1667, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }

+1668:         control.Rule(mines_left['few'] & lives_left['many'] & asteroids_hit['many'], drop_mine['yes']),

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_11 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_12 = PyNumber_And(__pyx_t_8, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __pyx_t_11 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_8 = PyNumber_And(__pyx_t_12, __pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __pyx_t_11 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_8, __pyx_t_11};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1668, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }

+1669:         control.Rule(mines_left['many'] & lives_left['few'] & asteroids_hit['few'], drop_mine['no']),

  __pyx_t_11 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = PyNumber_And(__pyx_t_8, __pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_8 = PyNumber_And(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_no); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1669, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_11);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_11);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_t_8, __pyx_t_12};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }

+1670:         control.Rule(mines_left['many'] & lives_left['few'] & asteroids_hit['okay'], drop_mine['no']),

  __pyx_t_12 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_14 = PyNumber_And(__pyx_t_8, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_okay); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_8 = PyNumber_And(__pyx_t_14, __pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_no); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_11))) {
    __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
    assert(__pyx_t_12);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
    __Pyx_INCREF(__pyx_t_12);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_12, __pyx_t_8, __pyx_t_13};
    __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1670, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }

+1671:         control.Rule(mines_left['many'] & lives_left['few'] & asteroids_hit['many'], drop_mine['yes']),

  __pyx_t_13 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_15 = PyNumber_And(__pyx_t_8, __pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
  __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_8 = PyNumber_And(__pyx_t_15, __pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
  __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_12))) {
    __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12);
    assert(__pyx_t_13);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
    __Pyx_INCREF(__pyx_t_13);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_13, __pyx_t_8, __pyx_t_14};
    __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1671, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
  }

+1672:         control.Rule(mines_left['many'] & lives_left['many'] & asteroids_hit['few'], drop_mine['yes']),

  __pyx_t_14 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_16 = PyNumber_And(__pyx_t_8, __pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_8 = PyNumber_And(__pyx_t_16, __pyx_t_15); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_13))) {
    __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13);
    assert(__pyx_t_14);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
    __Pyx_INCREF(__pyx_t_14);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_14, __pyx_t_8, __pyx_t_15};
    __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1672, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
  }

+1673:         control.Rule(mines_left['many'] & lives_left['many'] & asteroids_hit['okay'], drop_mine['yes']),

  __pyx_t_15 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_16 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_17 = PyNumber_And(__pyx_t_8, __pyx_t_16); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  __pyx_t_16 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_okay); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_8 = PyNumber_And(__pyx_t_17, __pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  __pyx_t_16 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_14))) {
    __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
    assert(__pyx_t_15);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14);
    __Pyx_INCREF(__pyx_t_15);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_14, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_8, __pyx_t_16};
    __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1673, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
  }

+1674:         control.Rule(mines_left['many'] & lives_left['many'] & asteroids_hit['many'], drop_mine['yes']),

  __pyx_t_16 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_mines_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_lives_left, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_18 = PyNumber_And(__pyx_t_8, __pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_asteroids_hit, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_8 = PyNumber_And(__pyx_t_18, __pyx_t_17); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_drop_mine, __pyx_mstate_global->__pyx_n_u_yes); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_15))) {
    __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_15);
    assert(__pyx_t_16);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15);
    __Pyx_INCREF(__pyx_t_16);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_15, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_16, __pyx_t_8, __pyx_t_17};
    __pyx_t_14 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1674, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
  }

 1675:     )

 1676: 

+1677:     mine_dropping_control = control.ControlSystem(rules)

  __pyx_t_14 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1677, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_ControlSystem); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1677, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_12))) {
    __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_12);
    assert(__pyx_t_14);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
    __Pyx_INCREF(__pyx_t_14);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_v_rules};
    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1677, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
  }
  __pyx_v_mine_dropping_control = __pyx_t_15;
  __pyx_t_15 = 0;

+1678:     mine_dropping_fis = control.ControlSystemSimulation(mine_dropping_control)

  __pyx_t_12 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1678, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_ControlSystemSimulation); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1678, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_13))) {
    __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13);
    assert(__pyx_t_12);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
    __Pyx_INCREF(__pyx_t_12);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_v_mine_dropping_control};
    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
  }
  __pyx_v_mine_dropping_fis = __pyx_t_15;
  __pyx_t_15 = 0;

+1679:     return mine_dropping_fis

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_mine_dropping_fis);
  __pyx_r = __pyx_v_mine_dropping_fis;
  goto __pyx_L0;

 1680: 

 1681: 

+1682: @lru_cache()

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_43generate_mine_fis_lookup_table(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_43generate_mine_fis_lookup_table = {"generate_mine_fis_lookup_table", (PyCFunction)__pyx_pw_14neo_controller_43generate_mine_fis_lookup_table, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_43generate_mine_fis_lookup_table(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("generate_mine_fis_lookup_table (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_42generate_mine_fis_lookup_table(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_42generate_mine_fis_lookup_table(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_v_mine_dropping_fis = NULL;
  PyObject *__pyx_v_lookup_table = NULL;
  long __pyx_v_mines_left;
  long __pyx_v_lives_left;
  PyObject *__pyx_v_asteroids_hit = NULL;
  PyObject *__pyx_v_drop_decision = NULL;
  PyObject *__pyx_v_should_drop_mine = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.generate_mine_fis_lookup_table", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mine_dropping_fis);
  __Pyx_XDECREF(__pyx_v_lookup_table);
  __Pyx_XDECREF(__pyx_v_asteroids_hit);
  __Pyx_XDECREF(__pyx_v_drop_decision);
  __Pyx_XDECREF(__pyx_v_should_drop_mine);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_10 = NULL;
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1682, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1682, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1682, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_dict_tuple_int_int_int_bool) < 0) __PYX_ERR(0, 1682, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_43generate_mine_fis_lookup_table, 0, __pyx_mstate_global->__pyx_n_u_generate_mine_fis_lookup_table, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[91])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1682, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_2};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1682, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_generate_mine_fis_lookup_table, __pyx_t_3) < 0) __PYX_ERR(0, 1682, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1683: def generate_mine_fis_lookup_table() -> dict[tuple[int, int, int], bool]:

+1684:     mine_dropping_fis = set_up_mine_fis()

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_set_up_mine_fis); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1684, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1684, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_mine_dropping_fis = __pyx_t_1;
  __pyx_t_1 = 0;

+1685:     lookup_table = {}

  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1685, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_lookup_table = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 1686: 

+1687:     for mines_left in range(1, 4):  # 0 to 3

  for (__pyx_t_5 = 1; __pyx_t_5 < 4; __pyx_t_5+=1) {
    __pyx_v_mines_left = __pyx_t_5;

+1688:         for lives_left in range(1, 4):  # 1 to 3

    for (__pyx_t_6 = 1; __pyx_t_6 < 4; __pyx_t_6+=1) {
      __pyx_v_lives_left = __pyx_t_6;

+1689:             for asteroids_hit in range(1, ASTEROIDS_HIT_VERY_GOOD + 1):

      __pyx_t_3 = NULL;
      __Pyx_INCREF(__pyx_builtin_range);
      __pyx_t_2 = __pyx_builtin_range; 
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_VERY_GOOD); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1689, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_8 = __Pyx_PyLong_AddObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1689, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_4 = 1;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_mstate_global->__pyx_int_1, __pyx_t_8};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1689, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
        __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2);
        __pyx_t_9 = 0;
        __pyx_t_10 = NULL;
      } else {
        __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1689, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_10 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1689, __pyx_L1_error)
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      for (;;) {
        if (likely(!__pyx_t_10)) {
          if (likely(PyList_CheckExact(__pyx_t_2))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1689, __pyx_L1_error)
              #endif
              if (__pyx_t_9 >= __pyx_temp) break;
            }
            __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_9);
            ++__pyx_t_9;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1689, __pyx_L1_error)
              #endif
              if (__pyx_t_9 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9));
            #else
            __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9);
            #endif
            ++__pyx_t_9;
          }
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1689, __pyx_L1_error)
        } else {
          __pyx_t_1 = __pyx_t_10(__pyx_t_2);
          if (unlikely(!__pyx_t_1)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1689, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_XDECREF_SET(__pyx_v_asteroids_hit, __pyx_t_1);
        __pyx_t_1 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
  }

 1690:                 # Input setup

+1691:                 mine_dropping_fis.input['mines_left'] = mines_left

        __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v_mines_left); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1691, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1691, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_mines_left, __pyx_t_1) < 0))) __PYX_ERR(0, 1691, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1692:                 mine_dropping_fis.input['lives_left'] = lives_left

        __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v_lives_left); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1692, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1692, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_lives_left, __pyx_t_1) < 0))) __PYX_ERR(0, 1692, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1693:                 mine_dropping_fis.input['asteroids_hit'] = asteroids_hit

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1693, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_asteroids_hit, __pyx_v_asteroids_hit) < 0))) __PYX_ERR(0, 1693, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1694:                 mine_dropping_fis.compute()

        __pyx_t_8 = __pyx_v_mine_dropping_fis;
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_4 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
          __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_compute, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1694, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1695:                 # Decision based on output

+1696:                 drop_decision = cast(float, mine_dropping_fis.output['drop_mine'])

        __pyx_t_8 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1696, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_output); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1696, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_11 = __Pyx_PyObject_Dict_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_drop_mine); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1696, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_4 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
          assert(__pyx_t_8);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_8);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
          __pyx_t_4 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_8, ((PyObject *)(&PyFloat_Type)), __pyx_t_11};
          __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1696, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_XDECREF_SET(__pyx_v_drop_decision, __pyx_t_1);
        __pyx_t_1 = 0;

+1697:                 should_drop_mine: bool = drop_decision > 5

        __pyx_t_1 = PyObject_RichCompare(__pyx_v_drop_decision, __pyx_mstate_global->__pyx_int_5, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1697, __pyx_L1_error)
        __Pyx_XDECREF_SET(__pyx_v_should_drop_mine, __pyx_t_1);
        __pyx_t_1 = 0;

+1698:                 lookup_table[(mines_left, lives_left, asteroids_hit)] = should_drop_mine

        __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v_mines_left); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1698, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v_lives_left); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1698, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1698, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_GIVEREF(__pyx_t_1);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1698, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_3);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 1698, __pyx_L1_error);
        __Pyx_INCREF(__pyx_v_asteroids_hit);
        __Pyx_GIVEREF(__pyx_v_asteroids_hit);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_v_asteroids_hit) != (0)) __PYX_ERR(0, 1698, __pyx_L1_error);
        __pyx_t_1 = 0;
        __pyx_t_3 = 0;
        if (unlikely((PyDict_SetItem(__pyx_v_lookup_table, __pyx_t_11, __pyx_v_should_drop_mine) < 0))) __PYX_ERR(0, 1698, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

+1699:     return lookup_table

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_lookup_table);
  __pyx_r = __pyx_v_lookup_table;
  goto __pyx_L0;

 1700: 

 1701: 

+1702: @lru_cache(maxsize=None)

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_45mine_fis(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_45mine_fis = {"mine_fis", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_45mine_fis, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_45mine_fis(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_num_mines_left = 0;
  PyObject *__pyx_v_num_lives_left = 0;
  PyObject *__pyx_v_num_asteroids_hit = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("mine_fis (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_num_mines_left,&__pyx_mstate_global->__pyx_n_u_num_lives_left,&__pyx_mstate_global->__pyx_n_u_num_asteroids_hit,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1702, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1702, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1702, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1702, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "mine_fis", 0) < 0) __PYX_ERR(0, 1702, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("mine_fis", 1, 3, 3, i); __PYX_ERR(0, 1702, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1702, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1702, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1702, __pyx_L3_error)
    }
    __pyx_v_num_mines_left = ((PyObject*)values[0]);
    __pyx_v_num_lives_left = ((PyObject*)values[1]);
    __pyx_v_num_asteroids_hit = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("mine_fis", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1702, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.mine_fis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_num_mines_left), (&PyLong_Type), 0, "num_mines_left", 2))) __PYX_ERR(0, 1703, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_num_lives_left), (&PyLong_Type), 0, "num_lives_left", 2))) __PYX_ERR(0, 1703, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_num_asteroids_hit), (&PyLong_Type), 0, "num_asteroids_hit", 2))) __PYX_ERR(0, 1703, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_44mine_fis(__pyx_self, __pyx_v_num_mines_left, __pyx_v_num_lives_left, __pyx_v_num_asteroids_hit);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_44mine_fis(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_num_mines_left, PyObject *__pyx_v_num_lives_left, PyObject *__pyx_v_num_asteroids_hit) {
  PyObject *__pyx_v_mine_dropping_fis = NULL;
  PyObject *__pyx_v_drop_decision = NULL;
  PyObject *__pyx_v_should_drop_mine = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_INCREF(__pyx_v_num_mines_left);
  __Pyx_INCREF(__pyx_v_num_lives_left);
  __Pyx_INCREF(__pyx_v_num_asteroids_hit);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.mine_fis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mine_dropping_fis);
  __Pyx_XDECREF(__pyx_v_drop_decision);
  __Pyx_XDECREF(__pyx_v_should_drop_mine);
  __Pyx_XDECREF(__pyx_v_num_mines_left);
  __Pyx_XDECREF(__pyx_v_num_lives_left);
  __Pyx_XDECREF(__pyx_v_num_asteroids_hit);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = NULL;
  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1702, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_10, NULL};
    __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1702, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_maxsize, Py_None, __pyx_t_9, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1702, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1702, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_5 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1702, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_mines_left, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1702, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_lives_left, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1702, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_asteroids_hit, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1702, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1702, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_45mine_fis, 0, __pyx_mstate_global->__pyx_n_u_mine_fis, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[92])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1702, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_9};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1702, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_mine_fis, __pyx_t_3) < 0) __PYX_ERR(0, 1702, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1703: def mine_fis(num_mines_left: int, num_lives_left: int, num_asteroids_hit: int) -> bool:

 1704:     # debug_print("Mine fis inputs", num_mines_left, num_lives_left, num_asteroids_hit)

+1705:     if num_mines_left == 0 or num_asteroids_hit < 8:

  __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_num_mines_left, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1705, __pyx_L1_error)
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_asteroids_hit, __pyx_mstate_global->__pyx_int_8, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1705, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1705, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+1706:         return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

+1707:     num_mines_left = min(num_mines_left, 3)

  __pyx_t_4 = 3;
  __Pyx_INCREF(__pyx_v_num_mines_left);
  __pyx_t_5 = __pyx_v_num_mines_left;
  __pyx_t_6 = __Pyx_PyLong_From_long(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1707, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1707, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1707, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (__pyx_t_1) {
    __pyx_t_7 = __Pyx_PyLong_From_long(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1707, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (!(likely(PyLong_CheckExact(__pyx_t_7)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_7))) __PYX_ERR(0, 1707, __pyx_L1_error)
    __pyx_t_3 = __pyx_t_7;
    __pyx_t_7 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_7 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF_SET(__pyx_v_num_mines_left, ((PyObject*)__pyx_t_7));
  __pyx_t_7 = 0;

+1708:     num_lives_left = min(num_lives_left, 3)

  __pyx_t_4 = 3;
  __Pyx_INCREF(__pyx_v_num_lives_left);
  __pyx_t_5 = __pyx_v_num_lives_left;
  __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1708, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1708, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1708, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_1) {
    __pyx_t_6 = __Pyx_PyLong_From_long(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1708, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (!(likely(PyLong_CheckExact(__pyx_t_6)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 1708, __pyx_L1_error)
    __pyx_t_7 = __pyx_t_6;
    __pyx_t_6 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_7 = __pyx_t_5;
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = __pyx_t_7;
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF_SET(__pyx_v_num_lives_left, ((PyObject*)__pyx_t_6));
  __pyx_t_6 = 0;

+1709:     num_asteroids_hit = min(num_asteroids_hit, ASTEROIDS_HIT_VERY_GOOD)

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_VERY_GOOD); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1709, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_INCREF(__pyx_v_num_asteroids_hit);
  __pyx_t_5 = __pyx_v_num_asteroids_hit;
  __pyx_t_3 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1709, __pyx_L1_error)
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1709, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_7 = __pyx_t_6;
  } else {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_7 = __pyx_t_5;
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __pyx_t_7;
  __Pyx_INCREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 1709, __pyx_L1_error)
  __Pyx_DECREF_SET(__pyx_v_num_asteroids_hit, ((PyObject*)__pyx_t_6));
  __pyx_t_6 = 0;

 1710:     # debug_print(f"Mine fis: Mines left: {num_mines_left}, lives left: {num_lives_left}, asteroids hit: {num_asteroids_hit}")

+1711:     mine_dropping_fis = set_up_mine_fis()

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_set_up_mine_fis); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1711, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1711, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_mine_dropping_fis = __pyx_t_6;
  __pyx_t_6 = 0;

+1712:     mine_dropping_fis.input['mines_left'] = num_mines_left

  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1712, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely((PyObject_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_mines_left, __pyx_v_num_mines_left) < 0))) __PYX_ERR(0, 1712, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+1713:     mine_dropping_fis.input['lives_left'] = num_lives_left

  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1713, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely((PyObject_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_lives_left, __pyx_v_num_lives_left) < 0))) __PYX_ERR(0, 1713, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+1714:     mine_dropping_fis.input['asteroids_hit'] = num_asteroids_hit

  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1714, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely((PyObject_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_asteroids_hit, __pyx_v_num_asteroids_hit) < 0))) __PYX_ERR(0, 1714, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 1715:     # Compute the output

+1716:     mine_dropping_fis.compute()

  __pyx_t_3 = __pyx_v_mine_dropping_fis;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_compute, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1716, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+1717:     drop_decision = cast(float, mine_dropping_fis.output['drop_mine'])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1717, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine_dropping_fis, __pyx_mstate_global->__pyx_n_u_output); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1717, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_drop_mine); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1717, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, ((PyObject *)(&PyFloat_Type)), __pyx_t_10};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1717, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_drop_decision = __pyx_t_6;
  __pyx_t_6 = 0;

 1718:     # Interpreting the output

+1719:     should_drop_mine: bool = drop_decision > 5  # True for drop, False for don't drop

  __pyx_t_6 = PyObject_RichCompare(__pyx_v_drop_decision, __pyx_mstate_global->__pyx_int_5, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1719, __pyx_L1_error)
  __pyx_v_should_drop_mine = __pyx_t_6;
  __pyx_t_6 = 0;

+1720:     return should_drop_mine

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_should_drop_mine);
  __pyx_r = __pyx_v_should_drop_mine;
  goto __pyx_L0;

 1721: 

 1722: 

+1723: @lru_cache()

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_47mine_fis_lookup_table(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_47mine_fis_lookup_table = {"mine_fis_lookup_table", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_47mine_fis_lookup_table, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_47mine_fis_lookup_table(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_num_mines_left = 0;
  PyObject *__pyx_v_num_lives_left = 0;
  PyObject *__pyx_v_num_asteroids_hit = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("mine_fis_lookup_table (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_num_mines_left,&__pyx_mstate_global->__pyx_n_u_num_lives_left,&__pyx_mstate_global->__pyx_n_u_num_asteroids_hit,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1723, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1723, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "mine_fis_lookup_table", 0) < 0) __PYX_ERR(0, 1723, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("mine_fis_lookup_table", 1, 3, 3, i); __PYX_ERR(0, 1723, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1723, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1723, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1723, __pyx_L3_error)
    }
    __pyx_v_num_mines_left = ((PyObject*)values[0]);
    __pyx_v_num_lives_left = ((PyObject*)values[1]);
    __pyx_v_num_asteroids_hit = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("mine_fis_lookup_table", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1723, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.mine_fis_lookup_table", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_num_mines_left), (&PyLong_Type), 0, "num_mines_left", 2))) __PYX_ERR(0, 1724, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_num_lives_left), (&PyLong_Type), 0, "num_lives_left", 2))) __PYX_ERR(0, 1724, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_num_asteroids_hit), (&PyLong_Type), 0, "num_asteroids_hit", 2))) __PYX_ERR(0, 1724, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_46mine_fis_lookup_table(__pyx_self, __pyx_v_num_mines_left, __pyx_v_num_lives_left, __pyx_v_num_asteroids_hit);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_46mine_fis_lookup_table(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_num_mines_left, PyObject *__pyx_v_num_lives_left, PyObject *__pyx_v_num_asteroids_hit) {
  PyObject *__pyx_v_lookup_table = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_INCREF(__pyx_v_num_mines_left);
  __Pyx_INCREF(__pyx_v_num_lives_left);
  __Pyx_INCREF(__pyx_v_num_asteroids_hit);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("neo_controller.mine_fis_lookup_table", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_lookup_table);
  __Pyx_XDECREF(__pyx_v_num_mines_left);
  __Pyx_XDECREF(__pyx_v_num_lives_left);
  __Pyx_XDECREF(__pyx_v_num_asteroids_hit);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = NULL;
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1723, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1723, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  __pyx_t_5 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1723, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_mines_left, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1723, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_lives_left, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1723, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_asteroids_hit, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1723, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1723, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_47mine_fis_lookup_table, 0, __pyx_mstate_global->__pyx_n_u_mine_fis_lookup_table, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[93])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1723, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1723, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_mine_fis_lookup_table, __pyx_t_3) < 0) __PYX_ERR(0, 1723, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1724: def mine_fis_lookup_table(num_mines_left: int, num_lives_left: int, num_asteroids_hit: int) -> bool:

 1725:     # The lru cache is simpler and just as fast as creating my own lookup table! Don't use this!

+1726:     if num_mines_left == 0 or num_asteroids_hit < 8:

  __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_num_mines_left, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1726, __pyx_L1_error)
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_asteroids_hit, __pyx_mstate_global->__pyx_int_8, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1726, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1726, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+1727:         return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

+1728:     lookup_table = generate_mine_fis_lookup_table()

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_generate_mine_fis_lookup_table); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1728, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1728, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_v_lookup_table = __pyx_t_3;
  __pyx_t_3 = 0;

+1729:     num_mines_left = min(num_mines_left, 3)

  __pyx_t_7 = 3;
  __Pyx_INCREF(__pyx_v_num_mines_left);
  __pyx_t_8 = __pyx_v_num_mines_left;
  __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_t_8, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1729, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1729, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_1) {
    __pyx_t_4 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1729, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (!(likely(PyLong_CheckExact(__pyx_t_4)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_4))) __PYX_ERR(0, 1729, __pyx_L1_error)
    __pyx_t_3 = __pyx_t_4;
    __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_3 = __pyx_t_8;
  }
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_4 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF_SET(__pyx_v_num_mines_left, ((PyObject*)__pyx_t_4));
  __pyx_t_4 = 0;

+1730:     num_lives_left = min(num_lives_left, 3)

  __pyx_t_7 = 3;
  __Pyx_INCREF(__pyx_v_num_lives_left);
  __pyx_t_8 = __pyx_v_num_lives_left;
  __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1730, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_8, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1730, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1730, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_1) {
    __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1730, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (!(likely(PyLong_CheckExact(__pyx_t_5)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_5))) __PYX_ERR(0, 1730, __pyx_L1_error)
    __pyx_t_4 = __pyx_t_5;
    __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_4 = __pyx_t_8;
  }
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_5 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF_SET(__pyx_v_num_lives_left, ((PyObject*)__pyx_t_5));
  __pyx_t_5 = 0;

+1731:     num_asteroids_hit = min(num_asteroids_hit, ASTEROIDS_HIT_VERY_GOOD)

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ASTEROIDS_HIT_VERY_GOOD); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1731, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_v_num_asteroids_hit);
  __pyx_t_8 = __pyx_v_num_asteroids_hit;
  __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_8, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1731, __pyx_L1_error)
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1731, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_4 = __pyx_t_5;
  } else {
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_4 = __pyx_t_8;
  }
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_5))) __PYX_ERR(0, 1731, __pyx_L1_error)
  __Pyx_DECREF_SET(__pyx_v_num_asteroids_hit, ((PyObject*)__pyx_t_5));
  __pyx_t_5 = 0;

 1732: 

+1733:     return lookup_table[(num_mines_left, num_lives_left, num_asteroids_hit)]

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1733, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_v_num_mines_left);
  __Pyx_GIVEREF(__pyx_v_num_mines_left);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_num_mines_left) != (0)) __PYX_ERR(0, 1733, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_num_lives_left);
  __Pyx_GIVEREF(__pyx_v_num_lives_left);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_num_lives_left) != (0)) __PYX_ERR(0, 1733, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_num_asteroids_hit);
  __Pyx_GIVEREF(__pyx_v_num_asteroids_hit);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_num_asteroids_hit) != (0)) __PYX_ERR(0, 1733, __pyx_L1_error);
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_lookup_table, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1733, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 1734: 

 1735: 

+1736: def check_mine_opportunity(ship_state: Ship, game_state: GameState, other_ships: list[Ship]) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_49check_mine_opportunity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_49check_mine_opportunity = {"check_mine_opportunity", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_49check_mine_opportunity, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_49check_mine_opportunity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  PyObject *__pyx_v_other_ships = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("check_mine_opportunity (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_other_ships,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1736, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1736, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1736, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1736, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "check_mine_opportunity", 0) < 0) __PYX_ERR(0, 1736, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("check_mine_opportunity", 1, 3, 3, i); __PYX_ERR(0, 1736, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1736, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1736, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1736, __pyx_L3_error)
    }
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[0]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[1]);
    __pyx_v_other_ships = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("check_mine_opportunity", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1736, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.check_mine_opportunity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 1736, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 1736, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_other_ships), (&PyList_Type), 0, "other_ships", 2))) __PYX_ERR(0, 1736, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_48check_mine_opportunity(__pyx_self, __pyx_v_ship_state, __pyx_v_game_state, __pyx_v_other_ships);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_48check_mine_opportunity(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, PyObject *__pyx_v_other_ships) {
  PyObject *__pyx_v_mine_ast_count = NULL;
  PyObject *__pyx_v_lives_fudge = 0;
  PyObject *__pyx_v_other_ship = NULL;
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  PyObject *__pyx_v_separation = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("neo_controller.check_mine_opportunity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mine_ast_count);
  __Pyx_XDECREF(__pyx_v_lives_fudge);
  __Pyx_XDECREF(__pyx_v_other_ship);
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_separation);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 1736, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 1736, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_other_ships, __pyx_mstate_global->__pyx_kp_u_list_Ship) < 0) __PYX_ERR(0, 1736, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 1736, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_49check_mine_opportunity, 0, __pyx_mstate_global->__pyx_n_u_check_mine_opportunity, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[94])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_check_mine_opportunity, __pyx_t_9) < 0) __PYX_ERR(0, 1736, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+1737:     if len(game_state.mines) > 1:

  __pyx_t_1 = __pyx_v_game_state->mines;
  __Pyx_INCREF(__pyx_t_1);
  if (unlikely(__pyx_t_1 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 1737, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1737, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = (__pyx_t_2 > 1);
  if (__pyx_t_3) {
/* … */
  }

+1738:         return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

+1739:     mine_ast_count = count_asteroids_in_mine_blast_radius(game_state, ship_state.position[0], ship_state.position[1], round(MINE_FUSE_TIME*FPS))

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_count_asteroids_in_mine_blast_ra); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_6, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_9 = NULL;
  __Pyx_INCREF(__pyx_builtin_round);
  __pyx_t_10 = __pyx_builtin_round; 
  __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = PyNumber_Multiply(__pyx_t_11, __pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __pyx_t_14 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_13};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_14, (2-__pyx_t_14) | (__pyx_t_14*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1739, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_t_14 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_14 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[5] = {__pyx_t_4, ((PyObject *)__pyx_v_game_state), __pyx_t_7, __pyx_t_8, __pyx_t_6};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_14, (5-__pyx_t_14) | (__pyx_t_14*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1739, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_mine_ast_count = __pyx_t_1;
  __pyx_t_1 = 0;

+1740:     lives_fudge: int = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_lives_fudge = __pyx_mstate_global->__pyx_int_0;

+1741:     for other_ship in other_ships:

  __pyx_t_1 = __pyx_v_other_ships; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1741, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1741, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_other_ship, __pyx_t_5);
    __pyx_t_5 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1742:         #if check_collision(ship_state.position[0], ship_state.position[1], MINE_BLAST_RADIUS - MINE_OTHER_SHIP_RADIUS_FUDGE, other_ship.position[0], other_ship.position[1], other_ship.radius):

+1743:         delta_x = ship_state.position[0] - other_ship.position[0]

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other_ship, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyNumber_Subtract(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_5);
    __pyx_t_5 = 0;

+1744:         delta_y = ship_state.position[1] - other_ship.position[1]

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other_ship, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyNumber_Subtract(__pyx_t_8, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_5);
    __pyx_t_5 = 0;

+1745:         separation = (MINE_BLAST_RADIUS - MINE_OTHER_SHIP_RADIUS_FUDGE) + other_ship.radius

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MINE_OTHER_SHIP_RADIUS_FUDGE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = PyNumber_Subtract(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_other_ship, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = PyNumber_Add(__pyx_t_8, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_5);
    __pyx_t_5 = 0;

+1746:         if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

    __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_15) {
    } else {
      __pyx_t_3 = __pyx_t_15;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_15) {
    } else {
      __pyx_t_3 = __pyx_t_15;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_5 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = PyNumber_Add(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_8, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 1746, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_3 = __pyx_t_15;
    __pyx_L7_bool_binop_done:;
    if (__pyx_t_3) {
/* … */
    }

 1747:             # print(f"Potentially bombing other ship. Giving reward of 10 asts!")

+1748:             mine_ast_count += MINE_OTHER_SHIP_ASTEROID_COUNT_EQUIVALENT

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MINE_OTHER_SHIP_ASTEROID_COUNT_E); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1748, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_v_mine_ast_count, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1748, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF_SET(__pyx_v_mine_ast_count, __pyx_t_6);
      __pyx_t_6 = 0;

+1749:     if ship_state.bullets_remaining == 0:

  __pyx_t_3 = (__pyx_v_ship_state->bullets_remaining == 0);
  if (__pyx_t_3) {
/* … */
  }

 1750:         # If ship is out of bullets, fudge the numbers to make the mine fis more likely to activate

+1751:         mine_ast_count *= 10

    __pyx_t_1 = __Pyx_PyLong_MultiplyObjC(__pyx_v_mine_ast_count, __pyx_mstate_global->__pyx_int_10, 10, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1751, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF_SET(__pyx_v_mine_ast_count, __pyx_t_1);
    __pyx_t_1 = 0;

+1752:         if len(game_state.mines) > 0:

    __pyx_t_1 = __pyx_v_game_state->mines;
    __Pyx_INCREF(__pyx_t_1);
    if (unlikely(__pyx_t_1 == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
      __PYX_ERR(0, 1752, __pyx_L1_error)
    }
    __pyx_t_2 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1752, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_3 = (__pyx_t_2 > 0);
    if (__pyx_t_3) {
/* … */
    }

 1753:             # We want to conserve mines more if we only have mines left and not bullets, and laying multiple mines at once is risky because the first one may blow asteroids away from the second, so the second one would be a waste

+1754:             return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      goto __pyx_L0;

+1755:         lives_fudge = 2 # Fudge it so that we don't care if we're at a low amount of lives. If we're out of bullets, then it's fine to be reckless, because the assumption is that it's most of the way through the scenario anyway. This assumption has been false for XFC 2024's second corridor scenario though, but it's good enough at avoiding that it doesn't matter.

    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2);
    __Pyx_DECREF_SET(__pyx_v_lives_fudge, __pyx_mstate_global->__pyx_int_2);

 1756:     # debug_print(f"Mine count inside: {mine_ast_count} compared to average density amount inside: {average_asteroids_inside_blast_radius}")

+1757:     return mine_fis(ship_state.mines_remaining, ship_state.lives_remaining + lives_fudge, mine_ast_count)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mine_fis); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1757, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_ship_state->mines_remaining); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1757, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_ship_state->lives_remaining); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1757, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_4 = PyNumber_Add(__pyx_t_7, __pyx_v_lives_fudge); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1757, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_14 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_14 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_t_8, __pyx_t_4, __pyx_v_mine_ast_count};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_14, (4-__pyx_t_14) | (__pyx_t_14*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1757, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1758: 

 1759: 

+1760: @lru_cache()

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_51setup_heuristic_maneuver_fis(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_51setup_heuristic_maneuver_fis = {"setup_heuristic_maneuver_fis", (PyCFunction)__pyx_pw_14neo_controller_51setup_heuristic_maneuver_fis, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_51setup_heuristic_maneuver_fis(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setup_heuristic_maneuver_fis (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_50setup_heuristic_maneuver_fis(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_50setup_heuristic_maneuver_fis(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_v_K = NULL;
  PyObject *__pyx_v_imminent_asteroid_speed = NULL;
  PyObject *__pyx_v_imminent_asteroid_relative_heading = NULL;
  PyObject *__pyx_v_largest_gap_relative_heading = NULL;
  PyObject *__pyx_v_nearby_asteroid_average_speed = NULL;
  PyObject *__pyx_v_nearby_asteroid_count = NULL;
  PyObject *__pyx_v_ship_accel_turn_rate = NULL;
  PyObject *__pyx_v_ship_cruise_speed = NULL;
  PyObject *__pyx_v_ship_cruise_turn_rate = NULL;
  PyObject *__pyx_v_ship_cruise_timesteps = NULL;
  PyObject *__pyx_v_ship_thrust_direction = NULL;
  PyObject *__pyx_v_rules = NULL;
  PyObject *__pyx_v_maneuver_control_system = NULL;
  PyObject *__pyx_v_maneuver_fis = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_24);
  __Pyx_XDECREF(__pyx_t_25);
  __Pyx_XDECREF(__pyx_t_26);
  __Pyx_XDECREF(__pyx_t_27);
  __Pyx_XDECREF(__pyx_t_28);
  __Pyx_XDECREF(__pyx_t_29);
  __Pyx_XDECREF(__pyx_t_30);
  __Pyx_XDECREF(__pyx_t_31);
  __Pyx_XDECREF(__pyx_t_32);
  __Pyx_XDECREF(__pyx_t_33);
  __Pyx_AddTraceback("neo_controller.setup_heuristic_maneuver_fis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_K);
  __Pyx_XDECREF(__pyx_v_imminent_asteroid_speed);
  __Pyx_XDECREF(__pyx_v_imminent_asteroid_relative_heading);
  __Pyx_XDECREF(__pyx_v_largest_gap_relative_heading);
  __Pyx_XDECREF(__pyx_v_nearby_asteroid_average_speed);
  __Pyx_XDECREF(__pyx_v_nearby_asteroid_count);
  __Pyx_XDECREF(__pyx_v_ship_accel_turn_rate);
  __Pyx_XDECREF(__pyx_v_ship_cruise_speed);
  __Pyx_XDECREF(__pyx_v_ship_cruise_turn_rate);
  __Pyx_XDECREF(__pyx_v_ship_cruise_timesteps);
  __Pyx_XDECREF(__pyx_v_ship_thrust_direction);
  __Pyx_XDECREF(__pyx_v_rules);
  __Pyx_XDECREF(__pyx_v_maneuver_control_system);
  __Pyx_XDECREF(__pyx_v_maneuver_fis);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = NULL;
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1760, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1760, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1760, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_control_ControlSystemSimulation) < 0) __PYX_ERR(0, 1760, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_51setup_heuristic_maneuver_fis, 0, __pyx_mstate_global->__pyx_n_u_setup_heuristic_maneuver_fis, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[95])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1760, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_2};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1760, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_setup_heuristic_maneuver_fis, __pyx_t_9) < 0) __PYX_ERR(0, 1760, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 1761: def setup_heuristic_maneuver_fis() -> control.ControlSystemSimulation:

+1762:     K = 0.8*FPS

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_0_8, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_K = __pyx_t_2;
  __pyx_t_2 = 0;

 1763:     # Antecedents (Inputs)

+1764:     imminent_asteroid_speed = control.Antecedent(arange(0, 301, 1), 'imminent_asteroid_speed')

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[5], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_imminent_asteroid_speed};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1764, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_imminent_asteroid_speed = __pyx_t_2;
  __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[5] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_301, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(0, 1764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]);

+1765:     imminent_asteroid_relative_heading = control.Antecedent(arange(0, 361, 1), 'imminent_asteroid_relative_heading')

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[6], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_imminent_asteroid_relative_headi};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1765, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_imminent_asteroid_relative_heading = __pyx_t_2;
  __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[6] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_361, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[6])) __PYX_ERR(0, 1765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[6]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]);

+1766:     largest_gap_relative_heading = control.Antecedent(arange(0, 361, 1), 'largest_gap_relative_heading')

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[6], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_largest_gap_relative_heading};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1766, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_largest_gap_relative_heading = __pyx_t_2;
  __pyx_t_2 = 0;

+1767:     nearby_asteroid_average_speed = control.Antecedent(arange(0, 301, 1), 'nearby_asteroid_average_speed')

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1767, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1767, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1767, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[5], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1767, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_nearby_asteroid_average_speed};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1767, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_nearby_asteroid_average_speed = __pyx_t_2;
  __pyx_t_2 = 0;

+1768:     nearby_asteroid_count = control.Antecedent(arange(0, 16, 1), 'nearby_asteroid_count')

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1768, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Antecedent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1768, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1768, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[7], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1768, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_nearby_asteroid_count};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1768, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_nearby_asteroid_count = __pyx_t_2;
  __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[7] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[7])) __PYX_ERR(0, 1768, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[7]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]);

 1769: 

 1770:     # Consequents (Outputs)

+1771:     ship_accel_turn_rate = control.Consequent(arange(-SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE + 1, 1), 'ship_accel_turn_rate')

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Consequent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = PyNumber_Negative(__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_10 = __Pyx_PyLong_AddObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_t_9, __pyx_t_10, __pyx_mstate_global->__pyx_int_1};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1771, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_accel_turn_rate};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1771, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_ship_accel_turn_rate = __pyx_t_2;
  __pyx_t_2 = 0;

+1772:     ship_cruise_speed = control.Consequent(arange(-SHIP_MAX_SPEED, SHIP_MAX_SPEED + 1, 1), 'ship_cruise_speed')

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Consequent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_3 = PyNumber_Negative(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_8 = __Pyx_PyLong_AddObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_t_3, __pyx_t_8, __pyx_mstate_global->__pyx_int_1};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1772, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_cruise_speed};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1772, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_ship_cruise_speed = __pyx_t_2;
  __pyx_t_2 = 0;

+1773:     ship_cruise_turn_rate = control.Consequent(arange(-SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE + 1, 1), 'ship_cruise_turn_rate')

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1773, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Consequent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1773, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1773, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1773, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = PyNumber_Negative(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1773, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1773, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1773, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_t_7, __pyx_t_9, __pyx_mstate_global->__pyx_int_1};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1773, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_cruise_turn_rate};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1773, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_ship_cruise_turn_rate = __pyx_t_2;
  __pyx_t_2 = 0;

+1774:     ship_cruise_timesteps = control.Consequent(arange(0, K + 1, 1), 'ship_cruise_timesteps')

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Consequent); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_v_K, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_mstate_global->__pyx_int_1};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1774, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_cruise_timesteps};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1774, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_ship_cruise_timesteps = __pyx_t_2;
  __pyx_t_2 = 0;

+1775:     ship_thrust_direction = control.Consequent(arange(-1, 2, 1), 'ship_thrust_direction')

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1775, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Consequent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1775, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1775, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[8], NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1775, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_thrust_direction};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1775, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_ship_thrust_direction = __pyx_t_2;
  __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[8] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_int_neg_1, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[8])) __PYX_ERR(0, 1775, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[8]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[8]);

 1776: 

 1777:     # Membership Functions for Antecedents

+1778:     imminent_asteroid_speed.automf(names=['slow', 'medium', 'fast'])

  __pyx_t_1 = __pyx_v_imminent_asteroid_speed;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_9 = PyList_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1778, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_slow);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_slow);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_n_u_slow) != (0)) __PYX_ERR(0, 1778, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_medium);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_medium);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_n_u_medium) != (0)) __PYX_ERR(0, 1778, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_fast);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_fast);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 2, __pyx_mstate_global->__pyx_n_u_fast) != (0)) __PYX_ERR(0, 1778, __pyx_L1_error);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, NULL};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1778, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_names, __pyx_t_9, __pyx_t_4, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1778, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_automf, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1778, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1779:     # imminent_asteroid_relative_heading.automf(names=['F', 'FL', 'L', 'BL', 'B', 'BR', 'R', 'FR'])

 1780:     # largest_gap_relative_heading.automf(names=['F', 'FL', 'L', 'BL', 'B', 'BR', 'R', 'FR'])

+1781:     nearby_asteroid_average_speed.automf(names=['slow', 'medium', 'fast'])

  __pyx_t_4 = __pyx_v_nearby_asteroid_average_speed;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_9 = PyList_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1781, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_slow);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_slow);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_n_u_slow) != (0)) __PYX_ERR(0, 1781, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_medium);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_medium);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_n_u_medium) != (0)) __PYX_ERR(0, 1781, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_fast);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_fast);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 2, __pyx_mstate_global->__pyx_n_u_fast) != (0)) __PYX_ERR(0, 1781, __pyx_L1_error);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, NULL};
    __pyx_t_1 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1781, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_names, __pyx_t_9, __pyx_t_1, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1781, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_automf, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_1);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1781, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1782:     nearby_asteroid_count.automf(names=['few', 'medium', 'many'])

  __pyx_t_1 = __pyx_v_nearby_asteroid_count;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_9 = PyList_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_few);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_few);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_n_u_few) != (0)) __PYX_ERR(0, 1782, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_medium);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_medium);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_n_u_medium) != (0)) __PYX_ERR(0, 1782, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_many);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_many);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 2, __pyx_mstate_global->__pyx_n_u_many) != (0)) __PYX_ERR(0, 1782, __pyx_L1_error);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, NULL};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1782, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_names, __pyx_t_9, __pyx_t_4, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 1782, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_automf, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1782, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1783: 

 1784:     # Define manual membership functions with 90 degrees width, dominant in 45 degrees

 1785:     # Forward (F) - Bimodal covering 0 to 45 and 315 to 360

+1786:     imminent_asteroid_relative_heading['F'] = fmax(

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_fmax); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1786, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
/* … */
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_F, __pyx_t_2) < 0))) __PYX_ERR(0, 1786, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1787:         trimf(imminent_asteroid_relative_heading.universe, [0, 0, 45]),  # Extends to 0 to 45

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1787, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1787, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1787, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1787, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1787, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_45);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_45);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_mstate_global->__pyx_int_45) != (0)) __PYX_ERR(0, 1787, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_8, __pyx_t_10};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1787, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }

+1788:         trimf(imminent_asteroid_relative_heading.universe, [315, 360, 360])  # Wraps from 315 to 360

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1788, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1788, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = PyList_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1788, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_315);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_315);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_315) != (0)) __PYX_ERR(0, 1788, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_360);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_360);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_360) != (0)) __PYX_ERR(0, 1788, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_360);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_360);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_360) != (0)) __PYX_ERR(0, 1788, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_5, __pyx_t_3};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1788, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1786, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }

 1789:     )

 1790: 

 1791:     # Forward Left (FL)

+1792:     imminent_asteroid_relative_heading['FL'] = trimf(imminent_asteroid_relative_heading.universe, [0, 45, 90])

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1792, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1792, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1792, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1792, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_45);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_45);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_45) != (0)) __PYX_ERR(0, 1792, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_90);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_90);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_90) != (0)) __PYX_ERR(0, 1792, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1792, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_FL, __pyx_t_2) < 0))) __PYX_ERR(0, 1792, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1793: 

 1794:     # Left (L)

+1795:     imminent_asteroid_relative_heading['L'] = trimf(imminent_asteroid_relative_heading.universe, [45, 90, 135])

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1795, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1795, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = PyList_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1795, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_45);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_45);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_int_45) != (0)) __PYX_ERR(0, 1795, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_90);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_90);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_int_90) != (0)) __PYX_ERR(0, 1795, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_135);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_135);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 2, __pyx_mstate_global->__pyx_int_135) != (0)) __PYX_ERR(0, 1795, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_1, __pyx_t_9};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1795, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_L, __pyx_t_2) < 0))) __PYX_ERR(0, 1795, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1796: 

 1797:     # Back Left (BL)

+1798:     imminent_asteroid_relative_heading['BL'] = trimf(imminent_asteroid_relative_heading.universe, [90, 135, 180])

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1798, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1798, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1798, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_90);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_90);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_90) != (0)) __PYX_ERR(0, 1798, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_135);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_135);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_135) != (0)) __PYX_ERR(0, 1798, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_180);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_180);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_180) != (0)) __PYX_ERR(0, 1798, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_BL, __pyx_t_2) < 0))) __PYX_ERR(0, 1798, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1799: 

 1800:     # Back (B)

+1801:     imminent_asteroid_relative_heading['B'] = trimf(imminent_asteroid_relative_heading.universe, [135, 180, 225])

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1801, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1801, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1801, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_135);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_135);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_135) != (0)) __PYX_ERR(0, 1801, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_180);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_180);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_180) != (0)) __PYX_ERR(0, 1801, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_225);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_225);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_225) != (0)) __PYX_ERR(0, 1801, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1801, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_B, __pyx_t_2) < 0))) __PYX_ERR(0, 1801, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1802: 

 1803:     # Back Right (BR)

+1804:     imminent_asteroid_relative_heading['BR'] = trimf(imminent_asteroid_relative_heading.universe, [180, 225, 270])

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1804, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1804, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = PyList_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1804, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_180);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_180);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_int_180) != (0)) __PYX_ERR(0, 1804, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_225);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_225);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_int_225) != (0)) __PYX_ERR(0, 1804, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_270);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_270);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 2, __pyx_mstate_global->__pyx_int_270) != (0)) __PYX_ERR(0, 1804, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_1, __pyx_t_9};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_BR, __pyx_t_2) < 0))) __PYX_ERR(0, 1804, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1805: 

 1806:     # Right (R)

+1807:     imminent_asteroid_relative_heading['R'] = trimf(imminent_asteroid_relative_heading.universe, [225, 270, 315])

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1807, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1807, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1807, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_225);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_225);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_225) != (0)) __PYX_ERR(0, 1807, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_270);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_270);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_270) != (0)) __PYX_ERR(0, 1807, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_315);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_315);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_315) != (0)) __PYX_ERR(0, 1807, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1807, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_R, __pyx_t_2) < 0))) __PYX_ERR(0, 1807, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1808: 

 1809:     # Forward Right (FR)

+1810:     imminent_asteroid_relative_heading['FR'] = trimf(imminent_asteroid_relative_heading.universe, [270, 315, 360])

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1810, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1810, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1810, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_270);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_270);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_270) != (0)) __PYX_ERR(0, 1810, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_315);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_315);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_315) != (0)) __PYX_ERR(0, 1810, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_360);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_360);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_360) != (0)) __PYX_ERR(0, 1810, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1810, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_FR, __pyx_t_2) < 0))) __PYX_ERR(0, 1810, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1811: 

 1812:     # Define manual membership functions with 90 degrees width, dominant in 45 degrees

 1813:     # Forward (F) - Bimodal covering 0 to 45 and 315 to 360

+1814:     largest_gap_relative_heading['F'] = fmax(

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_fmax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1814, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
/* … */
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_F, __pyx_t_2) < 0))) __PYX_ERR(0, 1814, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1815:         trimf(largest_gap_relative_heading.universe, [0, 0, 45]),  # Extends to 0 to 45

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1815, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1815, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyList_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1815, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1815, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1815, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_45);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_45);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_45) != (0)) __PYX_ERR(0, 1815, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_3, __pyx_t_5};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1815, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }

+1816:         trimf(largest_gap_relative_heading.universe, [315, 360, 360])  # Wraps from 315 to 360

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1816, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1816, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1816, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_315);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_315);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_mstate_global->__pyx_int_315) != (0)) __PYX_ERR(0, 1816, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_360);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_360);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_mstate_global->__pyx_int_360) != (0)) __PYX_ERR(0, 1816, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_360);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_360);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_mstate_global->__pyx_int_360) != (0)) __PYX_ERR(0, 1816, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_9, __pyx_t_10};
    __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1816, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_1, __pyx_t_8};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }

 1817:     )

 1818: 

 1819:     # Forward Left (FL)

+1820:     largest_gap_relative_heading['FL'] = trimf(largest_gap_relative_heading.universe, [0, 45, 90])

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1820, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_45);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_45);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_45) != (0)) __PYX_ERR(0, 1820, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_90);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_90);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_90) != (0)) __PYX_ERR(0, 1820, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1820, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_FL, __pyx_t_2) < 0))) __PYX_ERR(0, 1820, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1821: 

 1822:     # Left (L)

+1823:     largest_gap_relative_heading['L'] = trimf(largest_gap_relative_heading.universe, [45, 90, 135])

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_45);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_45);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_45) != (0)) __PYX_ERR(0, 1823, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_90);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_90);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_90) != (0)) __PYX_ERR(0, 1823, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_135);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_135);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_135) != (0)) __PYX_ERR(0, 1823, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1823, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_L, __pyx_t_2) < 0))) __PYX_ERR(0, 1823, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1824: 

 1825:     # Back Left (BL)

+1826:     largest_gap_relative_heading['BL'] = trimf(largest_gap_relative_heading.universe, [90, 135, 180])

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1826, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1826, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1826, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_90);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_90);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_90) != (0)) __PYX_ERR(0, 1826, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_135);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_135);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_mstate_global->__pyx_int_135) != (0)) __PYX_ERR(0, 1826, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_180);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_180);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_180) != (0)) __PYX_ERR(0, 1826, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_1, __pyx_t_8};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_BL, __pyx_t_2) < 0))) __PYX_ERR(0, 1826, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1827: 

 1828:     # Back (B)

+1829:     largest_gap_relative_heading['B'] = trimf(largest_gap_relative_heading.universe, [135, 180, 225])

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_135);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_135);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_135) != (0)) __PYX_ERR(0, 1829, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_180);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_180);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_180) != (0)) __PYX_ERR(0, 1829, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_225);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_225);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_225) != (0)) __PYX_ERR(0, 1829, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1829, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_B, __pyx_t_2) < 0))) __PYX_ERR(0, 1829, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1830: 

 1831:     # Back Right (BR)

+1832:     largest_gap_relative_heading['BR'] = trimf(largest_gap_relative_heading.universe, [180, 225, 270])

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1832, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1832, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1832, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_180);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_180);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_180) != (0)) __PYX_ERR(0, 1832, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_225);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_225);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_225) != (0)) __PYX_ERR(0, 1832, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_270);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_270);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_270) != (0)) __PYX_ERR(0, 1832, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1832, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_BR, __pyx_t_2) < 0))) __PYX_ERR(0, 1832, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1833: 

 1834:     # Right (R)

+1835:     largest_gap_relative_heading['R'] = trimf(largest_gap_relative_heading.universe, [225, 270, 315])

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1835, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1835, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1835, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_225);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_225);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_225) != (0)) __PYX_ERR(0, 1835, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_270);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_270);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_mstate_global->__pyx_int_270) != (0)) __PYX_ERR(0, 1835, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_315);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_315);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_315) != (0)) __PYX_ERR(0, 1835, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_1, __pyx_t_8};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1835, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_R, __pyx_t_2) < 0))) __PYX_ERR(0, 1835, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1836: 

 1837:     # Forward Right (FR)

+1838:     largest_gap_relative_heading['FR'] = trimf(largest_gap_relative_heading.universe, [270, 315, 360])

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1838, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1838, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1838, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_270);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_270);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_270) != (0)) __PYX_ERR(0, 1838, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_315);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_315);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_315) != (0)) __PYX_ERR(0, 1838, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_360);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_360);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_360) != (0)) __PYX_ERR(0, 1838, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1838, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_FR, __pyx_t_2) < 0))) __PYX_ERR(0, 1838, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1839:     # largest_gap_relative_heading['F'].view()

 1840: 

 1841:     # Membership Functions for Consequents

 1842: 

 1843:     # Acceleration Turn Rate

+1844:     ship_accel_turn_rate['R'] = trimf(ship_accel_turn_rate.universe, [-SHIP_MAX_TURN_RATE, -SHIP_MAX_TURN_RATE/2, 0])

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 1844, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 1844, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1844, __pyx_L1_error);
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_1, __pyx_t_10};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1844, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R, __pyx_t_2) < 0))) __PYX_ERR(0, 1844, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1845:     ship_accel_turn_rate['M'] = trimf(ship_accel_turn_rate.universe, [-SHIP_MAX_TURN_RATE/4, 0, SHIP_MAX_TURN_RATE/4])

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = PyNumber_Negative(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 1845, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1845, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 1845, __pyx_L1_error);
  __pyx_t_8 = 0;
  __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1845, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_M, __pyx_t_2) < 0))) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1846:     ship_accel_turn_rate['L'] = trimf(ship_accel_turn_rate.universe, [0, SHIP_MAX_TURN_RATE/2, SHIP_MAX_TURN_RATE])

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_3 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1846, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 1846, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 1846, __pyx_L1_error);
  __pyx_t_3 = 0;
  __pyx_t_7 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_1, __pyx_t_8};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1846, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_L, __pyx_t_2) < 0))) __PYX_ERR(0, 1846, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1847:     # ship_accel_turn_rate.view()

 1848:     # Cruise Speed

+1849:     ship_cruise_speed['slow'] = trimf(ship_cruise_speed.universe, [0, 0, SHIP_MAX_SPEED/2])

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_7 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1849, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1849, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 1849, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_10};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1849, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_slow, __pyx_t_2) < 0))) __PYX_ERR(0, 1849, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1850:     ship_cruise_speed['medium'] = trimf(ship_cruise_speed.universe, [0, SHIP_MAX_SPEED/2, SHIP_MAX_SPEED])

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyList_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1850, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 1850, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_t_4) != (0)) __PYX_ERR(0, 1850, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_4 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_1, __pyx_t_3};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1850, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_medium, __pyx_t_2) < 0))) __PYX_ERR(0, 1850, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1851:     ship_cruise_speed['fast'] = trimf(ship_cruise_speed.universe, [SHIP_MAX_SPEED/2, SHIP_MAX_SPEED, SHIP_MAX_SPEED])

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_9 = PyList_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 1851, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 1851, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 1851, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_8 = 0;
  __pyx_t_7 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_1, __pyx_t_9};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1851, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_fast, __pyx_t_2) < 0))) __PYX_ERR(0, 1851, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1852:     # ship_cruise_speed.view()

 1853:     # Cruise Turn Rate

+1854:     ship_cruise_turn_rate['R'] = trimf(ship_cruise_turn_rate.universe, [-SHIP_MAX_TURN_RATE, -SHIP_MAX_TURN_RATE/2, 0])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_7 = PyNumber_Negative(__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_8 = PyNumber_Negative(__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 1854, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_10);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 1854, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1854, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_10 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_1, __pyx_t_8};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1854, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_R, __pyx_t_2) < 0))) __PYX_ERR(0, 1854, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1855:     ship_cruise_turn_rate['M'] = trimf(ship_cruise_turn_rate.universe, [-SHIP_MAX_TURN_RATE/4, 0, SHIP_MAX_TURN_RATE/4])

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_10 = PyNumber_Negative(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_7 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 1855, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1855, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 1855, __pyx_L1_error);
  __pyx_t_3 = 0;
  __pyx_t_7 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_t_10};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1855, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_M, __pyx_t_2) < 0))) __PYX_ERR(0, 1855, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1856:     ship_cruise_turn_rate['L'] = trimf(ship_cruise_turn_rate.universe, [0, SHIP_MAX_TURN_RATE/2, SHIP_MAX_TURN_RATE])

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_7 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_3 = PyList_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1856, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 1856, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_t_9) != (0)) __PYX_ERR(0, 1856, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_9 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_1, __pyx_t_3};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1856, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_L, __pyx_t_2) < 0))) __PYX_ERR(0, 1856, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1857:     # ship_cruise_turn_rate.view()

 1858:     # Cruise Time Steps

+1859:     ship_cruise_timesteps['short'] = trimf(ship_cruise_timesteps.universe, [0, K/4, K/2])

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_8 = __Pyx_PyLong_TrueDivideObjC(__pyx_v_K, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = __Pyx_PyLong_TrueDivideObjC(__pyx_v_K, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1859, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 1859, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_9) != (0)) __PYX_ERR(0, 1859, __pyx_L1_error);
  __pyx_t_8 = 0;
  __pyx_t_9 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1859, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_short, __pyx_t_2) < 0))) __PYX_ERR(0, 1859, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1860:     ship_cruise_timesteps['medium'] = trimf(ship_cruise_timesteps.universe, [K/4, K/2, 3*K/4])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_10 = __Pyx_PyLong_TrueDivideObjC(__pyx_v_K, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_9 = __Pyx_PyLong_TrueDivideObjC(__pyx_v_K, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_8 = __Pyx_PyLong_MultiplyCObj(__pyx_mstate_global->__pyx_int_3, __pyx_v_K, 3, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_10);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_10) != (0)) __PYX_ERR(0, 1860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 1860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_4) != (0)) __PYX_ERR(0, 1860, __pyx_L1_error);
  __pyx_t_10 = 0;
  __pyx_t_9 = 0;
  __pyx_t_4 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_1, __pyx_t_8};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1860, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_medium, __pyx_t_2) < 0))) __PYX_ERR(0, 1860, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1861:     ship_cruise_timesteps['long'] = trimf(ship_cruise_timesteps.universe, [K/2, 3*K/4, K])

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyLong_TrueDivideObjC(__pyx_v_K, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyLong_MultiplyCObj(__pyx_mstate_global->__pyx_int_3, __pyx_v_K, 3, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_9 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, 4, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 1861, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 1861, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_K);
  __Pyx_GIVEREF(__pyx_v_K);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_v_K) != (0)) __PYX_ERR(0, 1861, __pyx_L1_error);
  __pyx_t_3 = 0;
  __pyx_t_9 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1861, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_long, __pyx_t_2) < 0))) __PYX_ERR(0, 1861, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1862:     # ship_cruise_timesteps.view()

 1863: 

+1864:     ship_thrust_direction['F'] = trimf(ship_thrust_direction.universe, [0, 1, 1])

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1864, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1864, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1864, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_1, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1864, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_F, __pyx_t_2) < 0))) __PYX_ERR(0, 1864, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1865:     ship_thrust_direction['B'] = trimf(ship_thrust_direction.universe, [-1, -1, 0])

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trimf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_universe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1865, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1865, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 1865, __pyx_L1_error);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_8};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1865, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (unlikely((PyObject_SetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B, __pyx_t_2) < 0))) __PYX_ERR(0, 1865, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1866: 

 1867:     rules = (

 1868:         # The faster the imminent asteroid approaches, the quicker we want to get out of there

+1869:         control.Rule(imminent_asteroid_speed['slow'], ship_cruise_speed['slow']),

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_speed, __pyx_mstate_global->__pyx_n_u_slow); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_slow); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_8, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1869, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
/* … */
  __pyx_t_31 = PyTuple_New(25); if (unlikely(!__pyx_t_31)) __PYX_ERR(0, 1869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_31);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 4, __pyx_t_9) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 5, __pyx_t_3) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_10);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 6, __pyx_t_10) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 7, __pyx_t_5) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_11);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 8, __pyx_t_11) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_14);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 9, __pyx_t_14) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_15);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 10, __pyx_t_15) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_16);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 11, __pyx_t_16) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_18);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 12, __pyx_t_18) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_19);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 13, __pyx_t_19) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_20);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 14, __pyx_t_20) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_21);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 15, __pyx_t_21) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_22);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 16, __pyx_t_22) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_23);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 17, __pyx_t_23) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_24);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 18, __pyx_t_24) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_25);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 19, __pyx_t_25) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_26);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 20, __pyx_t_26) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_27);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 21, __pyx_t_27) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_28);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 22, __pyx_t_28) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_29);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 23, __pyx_t_29) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_30);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 24, __pyx_t_30) != (0)) __PYX_ERR(0, 1869, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_t_1 = 0;
  __pyx_t_7 = 0;
  __pyx_t_4 = 0;
  __pyx_t_9 = 0;
  __pyx_t_3 = 0;
  __pyx_t_10 = 0;
  __pyx_t_5 = 0;
  __pyx_t_11 = 0;
  __pyx_t_14 = 0;
  __pyx_t_15 = 0;
  __pyx_t_16 = 0;
  __pyx_t_18 = 0;
  __pyx_t_19 = 0;
  __pyx_t_20 = 0;
  __pyx_t_21 = 0;
  __pyx_t_22 = 0;
  __pyx_t_23 = 0;
  __pyx_t_24 = 0;
  __pyx_t_25 = 0;
  __pyx_t_26 = 0;
  __pyx_t_27 = 0;
  __pyx_t_28 = 0;
  __pyx_t_29 = 0;
  __pyx_t_30 = 0;
  __pyx_v_rules = ((PyObject*)__pyx_t_31);
  __pyx_t_31 = 0;

+1870:         control.Rule(imminent_asteroid_speed['medium'], ship_cruise_speed['medium']),

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_speed, __pyx_mstate_global->__pyx_n_u_medium); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_medium); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_8, __pyx_t_9};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1870, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }

+1871:         control.Rule(imminent_asteroid_speed['fast'], ship_cruise_speed['fast']),

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_speed, __pyx_mstate_global->__pyx_n_u_fast); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_fast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_3};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1871, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }

 1872:         # Adjust ship speed depending on the surrounding asteroids' speeds

+1873:         control.Rule(nearby_asteroid_average_speed['slow'], ship_cruise_speed['slow']),

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_nearby_asteroid_average_speed, __pyx_mstate_global->__pyx_n_u_slow); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_slow); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_8, __pyx_t_10};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1873, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }

+1874:         control.Rule(nearby_asteroid_average_speed['medium'], ship_cruise_speed['medium']),

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1874, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1874, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_nearby_asteroid_average_speed, __pyx_mstate_global->__pyx_n_u_medium); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1874, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_medium); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1874, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_8, __pyx_t_5};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1874, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }

+1875:         control.Rule(nearby_asteroid_average_speed['fast'], ship_cruise_speed['fast']),

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_nearby_asteroid_average_speed, __pyx_mstate_global->__pyx_n_u_fast); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_11 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_fast); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_8, __pyx_t_11};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1875, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }

 1876:         # Cruise length should depend on asteroid density a bit, since a lower density means we should be able to travel farther without hitting anything

+1877:         control.Rule(nearby_asteroid_count['few'], (ship_cruise_timesteps['long'], ship_cruise_speed['fast'])),

  __pyx_t_11 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_nearby_asteroid_count, __pyx_mstate_global->__pyx_n_u_few); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_long); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_fast); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12) != (0)) __PYX_ERR(0, 1877, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_13) != (0)) __PYX_ERR(0, 1877, __pyx_L1_error);
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_11);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_11);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_t_8, __pyx_t_14};
    __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1877, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }

+1878:         control.Rule(nearby_asteroid_count['medium'], (ship_cruise_timesteps['medium'], ship_cruise_speed['medium'])),

  __pyx_t_14 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_nearby_asteroid_count, __pyx_mstate_global->__pyx_n_u_medium); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_medium); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_medium); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1878, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1878, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_11))) {
    __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_11);
    assert(__pyx_t_14);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
    __Pyx_INCREF(__pyx_t_14);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_14, __pyx_t_8, __pyx_t_15};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1878, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }

+1879:         control.Rule(nearby_asteroid_count['many'], (ship_cruise_timesteps['short'], ship_cruise_speed['slow'])),

  __pyx_t_15 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_nearby_asteroid_count, __pyx_mstate_global->__pyx_n_u_many); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_short); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_slow); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_16 = PyTuple_New(2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_12) != (0)) __PYX_ERR(0, 1879, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_16, 1, __pyx_t_13) != (0)) __PYX_ERR(0, 1879, __pyx_L1_error);
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_14))) {
    __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
    assert(__pyx_t_15);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14);
    __Pyx_INCREF(__pyx_t_15);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_14, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_8, __pyx_t_16};
    __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1879, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
  }

 1880:         # Whichever direction the imminent asteroid is from us, we want to avoid running directly at that asteroid

+1881:         control.Rule(imminent_asteroid_relative_heading['F'], (ship_thrust_direction['B'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),

  __pyx_t_16 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_18 = PyTuple_New(3); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1881, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1881, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1881, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_15))) {
    __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_15);
    assert(__pyx_t_16);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15);
    __Pyx_INCREF(__pyx_t_16);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_15, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_16, __pyx_t_8, __pyx_t_18};
    __pyx_t_14 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1881, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
  }

+1882:         control.Rule(imminent_asteroid_relative_heading['B'], (ship_thrust_direction['F'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),

  __pyx_t_18 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_19 = PyTuple_New(3); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_19);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1882, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1882, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1882, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_16))) {
    __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_16);
    assert(__pyx_t_18);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_16);
    __Pyx_INCREF(__pyx_t_18);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_16, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_18, __pyx_t_8, __pyx_t_19};
    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_16, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1882, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
  }

+1883:         control.Rule(imminent_asteroid_relative_heading['L'], (ship_thrust_direction['B'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),  # , ~(ship_thrust_direction['B'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),

  __pyx_t_19 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_20 = PyTuple_New(3); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1883, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1883, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1883, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_18))) {
    __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_18);
    assert(__pyx_t_19);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18);
    __Pyx_INCREF(__pyx_t_19);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_18, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_19, __pyx_t_8, __pyx_t_20};
    __pyx_t_16 = __Pyx_PyObject_FastCall(__pyx_t_18, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1883, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
  }

+1884:         control.Rule(imminent_asteroid_relative_heading['R'], (ship_thrust_direction['B'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['L'])),  # & ~(ship_thrust_direction['B'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['L'])),

  __pyx_t_20 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_19);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_21 = PyTuple_New(3); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1884, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1884, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1884, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_19))) {
    __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_19);
    assert(__pyx_t_20);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19);
    __Pyx_INCREF(__pyx_t_20);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_19, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_20, __pyx_t_8, __pyx_t_21};
    __pyx_t_18 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1884, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
  }

+1885:         control.Rule(imminent_asteroid_relative_heading['FL'], (ship_thrust_direction['B'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),  # & ~(ship_thrust_direction['F'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['L'])),

  __pyx_t_21 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_FL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_22 = PyTuple_New(3); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1885, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_22, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1885, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_22, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1885, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_20))) {
    __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_20);
    assert(__pyx_t_21);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_20);
    __Pyx_INCREF(__pyx_t_21);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_20, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_21, __pyx_t_8, __pyx_t_22};
    __pyx_t_19 = __Pyx_PyObject_FastCall(__pyx_t_20, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
    if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1885, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
  }

+1886:         control.Rule(imminent_asteroid_relative_heading['FR'], (ship_thrust_direction['B'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['L'])),  # & ~(ship_thrust_direction['F'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['R'])),

  __pyx_t_22 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_FR); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1886, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1886, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_23, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1886, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_21))) {
    __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_21);
    assert(__pyx_t_22);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21);
    __Pyx_INCREF(__pyx_t_22);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_21, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_22, __pyx_t_8, __pyx_t_23};
    __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1886, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
  }

+1887:         control.Rule(imminent_asteroid_relative_heading['BL'], (ship_thrust_direction['B'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['L'])),  # & ~(ship_thrust_direction['B'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['R'])),

  __pyx_t_23 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_BL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_24 = PyTuple_New(3); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_24);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_24, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1887, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_24, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1887, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_24, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1887, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_22))) {
    __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_22);
    assert(__pyx_t_23);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_22);
    __Pyx_INCREF(__pyx_t_23);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_22, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_23, __pyx_t_8, __pyx_t_24};
    __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_22, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1887, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }

+1888:         control.Rule(imminent_asteroid_relative_heading['BR'], (ship_thrust_direction['B'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),  # & ~(ship_thrust_direction['B'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['L'])),

  __pyx_t_24 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_imminent_asteroid_relative_heading, __pyx_mstate_global->__pyx_n_u_BR); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_25 = PyTuple_New(3); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_25, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1888, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_25, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1888, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_25, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1888, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_23))) {
    __pyx_t_24 = PyMethod_GET_SELF(__pyx_t_23);
    assert(__pyx_t_24);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
    __Pyx_INCREF(__pyx_t_24);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_24, __pyx_t_8, __pyx_t_25};
    __pyx_t_22 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1888, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_22);
  }

 1889:         # Wherever the largest gap to escape is, we want to go there

+1890:         control.Rule(largest_gap_relative_heading['F'], (ship_thrust_direction['F'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['M'])),

  __pyx_t_25 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 1890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_24);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_26 = PyTuple_New(3); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 1890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_26);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_26, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1890, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_26, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1890, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_26, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1890, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_24))) {
    __pyx_t_25 = PyMethod_GET_SELF(__pyx_t_24);
    assert(__pyx_t_25);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_24);
    __Pyx_INCREF(__pyx_t_25);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_24, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_25, __pyx_t_8, __pyx_t_26};
    __pyx_t_23 = __Pyx_PyObject_FastCall(__pyx_t_24, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
    if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1890, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
  }

+1891:         control.Rule(largest_gap_relative_heading['B'], (ship_thrust_direction['B'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['M'])),

  __pyx_t_26 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_27 = PyTuple_New(3); if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_27);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1891, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_27, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1891, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_27, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1891, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_25))) {
    __pyx_t_26 = PyMethod_GET_SELF(__pyx_t_25);
    assert(__pyx_t_26);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_25);
    __Pyx_INCREF(__pyx_t_26);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_25, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_26, __pyx_t_8, __pyx_t_27};
    __pyx_t_24 = __Pyx_PyObject_FastCall(__pyx_t_25, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 1891, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_24);
  }

+1892:         control.Rule(largest_gap_relative_heading['L'], (ship_thrust_direction['F'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['L'])),  # | (ship_thrust_direction['B'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),

  __pyx_t_27 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_26 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 1892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_26);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_28 = PyTuple_New(3); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_28);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_28, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1892, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_28, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1892, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_28, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1892, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_26))) {
    __pyx_t_27 = PyMethod_GET_SELF(__pyx_t_26);
    assert(__pyx_t_27);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_26);
    __Pyx_INCREF(__pyx_t_27);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_26, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_27, __pyx_t_8, __pyx_t_28};
    __pyx_t_25 = __Pyx_PyObject_FastCall(__pyx_t_26, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_27); __pyx_t_27 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
    __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
    if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 1892, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
  }

+1893:         control.Rule(largest_gap_relative_heading['R'], (ship_thrust_direction['F'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['R'])),  # | (ship_thrust_direction['B'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['L'])),

  __pyx_t_28 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_27 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 1893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_27);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_29 = PyTuple_New(3); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 1893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_29);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_29, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1893, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_29, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1893, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_29, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1893, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_27))) {
    __pyx_t_28 = PyMethod_GET_SELF(__pyx_t_27);
    assert(__pyx_t_28);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_27);
    __Pyx_INCREF(__pyx_t_28);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_27, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_28, __pyx_t_8, __pyx_t_29};
    __pyx_t_26 = __Pyx_PyObject_FastCall(__pyx_t_27, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0;
    if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 1893, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_26);
  }

+1894:         control.Rule(largest_gap_relative_heading['FL'], (ship_thrust_direction['F'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['M'])),  # | (ship_thrust_direction['F'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['L'])),

  __pyx_t_29 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_28 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_28);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_FL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_30 = PyTuple_New(3); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_30);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_30, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1894, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_30, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1894, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_30, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1894, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_28))) {
    __pyx_t_29 = PyMethod_GET_SELF(__pyx_t_28);
    assert(__pyx_t_29);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_28);
    __Pyx_INCREF(__pyx_t_29);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_28, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_29, __pyx_t_8, __pyx_t_30};
    __pyx_t_27 = __Pyx_PyObject_FastCall(__pyx_t_28, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
    if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 1894, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_27);
  }

+1895:         control.Rule(largest_gap_relative_heading['FR'], (ship_thrust_direction['F'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['M'])),  # | (ship_thrust_direction['F'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['R'])),

  __pyx_t_30 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 1895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_29);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_FR); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_F); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_31 = PyTuple_New(3); if (unlikely(!__pyx_t_31)) __PYX_ERR(0, 1895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_31);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1895, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1895, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_31, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1895, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_29))) {
    __pyx_t_30 = PyMethod_GET_SELF(__pyx_t_29);
    assert(__pyx_t_30);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
    __Pyx_INCREF(__pyx_t_30);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_30, __pyx_t_8, __pyx_t_31};
    __pyx_t_28 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_31); __pyx_t_31 = 0;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_28);
  }

+1896:         control.Rule(largest_gap_relative_heading['BL'], (ship_thrust_direction['B'], ship_accel_turn_rate['R'], ship_cruise_turn_rate['M'])),  # | (ship_thrust_direction['B'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['R'])),

  __pyx_t_31 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 1896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_30);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_BL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_R); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_32 = PyTuple_New(3); if (unlikely(!__pyx_t_32)) __PYX_ERR(0, 1896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_32);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_32, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 1896, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_32, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1896, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_32, 2, __pyx_t_17) != (0)) __PYX_ERR(0, 1896, __pyx_L1_error);
  __pyx_t_13 = 0;
  __pyx_t_12 = 0;
  __pyx_t_17 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_30))) {
    __pyx_t_31 = PyMethod_GET_SELF(__pyx_t_30);
    assert(__pyx_t_31);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_30);
    __Pyx_INCREF(__pyx_t_31);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_30, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_31, __pyx_t_8, __pyx_t_32};
    __pyx_t_29 = __Pyx_PyObject_FastCall(__pyx_t_30, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_31); __pyx_t_31 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_32); __pyx_t_32 = 0;
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 1896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
  }

+1897:         control.Rule(largest_gap_relative_heading['BR'], (ship_thrust_direction['B'], ship_accel_turn_rate['L'], ship_cruise_turn_rate['M'])),  # | (ship_thrust_direction['B'], ship_accel_turn_rate['M'], ship_cruise_turn_rate['L'])),

  __pyx_t_32 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_31 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Rule); if (unlikely(!__pyx_t_31)) __PYX_ERR(0, 1897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_31);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_BR); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_thrust_direction, __pyx_mstate_global->__pyx_n_u_B); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_L); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_M); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_33 = PyTuple_New(3); if (unlikely(!__pyx_t_33)) __PYX_ERR(0, 1897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_33);
  __Pyx_GIVEREF(__pyx_t_17);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_33, 0, __pyx_t_17) != (0)) __PYX_ERR(0, 1897, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_33, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 1897, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_33, 2, __pyx_t_13) != (0)) __PYX_ERR(0, 1897, __pyx_L1_error);
  __pyx_t_17 = 0;
  __pyx_t_12 = 0;
  __pyx_t_13 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_31))) {
    __pyx_t_32 = PyMethod_GET_SELF(__pyx_t_31);
    assert(__pyx_t_32);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_31);
    __Pyx_INCREF(__pyx_t_32);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_31, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_32, __pyx_t_8, __pyx_t_33};
    __pyx_t_30 = __Pyx_PyObject_FastCall(__pyx_t_31, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_32); __pyx_t_32 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_33); __pyx_t_33 = 0;
    __Pyx_DECREF(__pyx_t_31); __pyx_t_31 = 0;
    if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 1897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
  }

 1898:     )

 1899: 

 1900:     # Create the control system

+1901:     maneuver_control_system = control.ControlSystem(rules)

  __pyx_t_30 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 1901, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_29);
  __pyx_t_28 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_ControlSystem); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1901, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_28);
  __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_28))) {
    __pyx_t_30 = PyMethod_GET_SELF(__pyx_t_28);
    assert(__pyx_t_30);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_28);
    __Pyx_INCREF(__pyx_t_30);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_28, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_30, __pyx_v_rules};
    __pyx_t_31 = __Pyx_PyObject_FastCall(__pyx_t_28, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
    if (unlikely(!__pyx_t_31)) __PYX_ERR(0, 1901, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_31);
  }
  __pyx_v_maneuver_control_system = __pyx_t_31;
  __pyx_t_31 = 0;

+1902:     maneuver_fis = control.ControlSystemSimulation(maneuver_control_system)

  __pyx_t_28 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_control); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 1902, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_30);
  __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_ControlSystemSimulation); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 1902, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_29);
  __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_29))) {
    __pyx_t_28 = PyMethod_GET_SELF(__pyx_t_29);
    assert(__pyx_t_28);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
    __Pyx_INCREF(__pyx_t_28);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_28, __pyx_v_maneuver_control_system};
    __pyx_t_31 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 0;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    if (unlikely(!__pyx_t_31)) __PYX_ERR(0, 1902, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_31);
  }
  __pyx_v_maneuver_fis = __pyx_t_31;
  __pyx_t_31 = 0;

+1903:     return maneuver_fis

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_maneuver_fis);
  __pyx_r = __pyx_v_maneuver_fis;
  goto __pyx_L0;

 1904: 

 1905: 

+1906: def maneuver_heuristic_fis(imminent_asteroid_speed: float, imminent_asteroid_relative_heading: float, largest_gap_relative_heading: float, nearby_asteroid_average_speed: float, nearby_asteroid_count: int) -> tuple[float, float, float, float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_53maneuver_heuristic_fis(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_53maneuver_heuristic_fis = {"maneuver_heuristic_fis", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_53maneuver_heuristic_fis, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_53maneuver_heuristic_fis(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_imminent_asteroid_speed;
  double __pyx_v_imminent_asteroid_relative_heading;
  double __pyx_v_largest_gap_relative_heading;
  double __pyx_v_nearby_asteroid_average_speed;
  PyObject *__pyx_v_nearby_asteroid_count = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("maneuver_heuristic_fis (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_imminent_asteroid_speed,&__pyx_mstate_global->__pyx_n_u_imminent_asteroid_relative_headi,&__pyx_mstate_global->__pyx_n_u_largest_gap_relative_heading,&__pyx_mstate_global->__pyx_n_u_nearby_asteroid_average_speed,&__pyx_mstate_global->__pyx_n_u_nearby_asteroid_count,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1906, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1906, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1906, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1906, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1906, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1906, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "maneuver_heuristic_fis", 0) < 0) __PYX_ERR(0, 1906, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 5; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("maneuver_heuristic_fis", 1, 5, 5, i); __PYX_ERR(0, 1906, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 5)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1906, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1906, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1906, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1906, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1906, __pyx_L3_error)
    }
    __pyx_v_imminent_asteroid_speed = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_imminent_asteroid_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1906, __pyx_L3_error)
    __pyx_v_imminent_asteroid_relative_heading = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_imminent_asteroid_relative_heading == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1906, __pyx_L3_error)
    __pyx_v_largest_gap_relative_heading = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_largest_gap_relative_heading == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1906, __pyx_L3_error)
    __pyx_v_nearby_asteroid_average_speed = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nearby_asteroid_average_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1906, __pyx_L3_error)
    __pyx_v_nearby_asteroid_count = ((PyObject*)values[4]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("maneuver_heuristic_fis", 1, 5, 5, __pyx_nargs); __PYX_ERR(0, 1906, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.maneuver_heuristic_fis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_nearby_asteroid_count), (&PyLong_Type), 0, "nearby_asteroid_count", 2))) __PYX_ERR(0, 1906, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_52maneuver_heuristic_fis(__pyx_self, __pyx_v_imminent_asteroid_speed, __pyx_v_imminent_asteroid_relative_heading, __pyx_v_largest_gap_relative_heading, __pyx_v_nearby_asteroid_average_speed, __pyx_v_nearby_asteroid_count);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_52maneuver_heuristic_fis(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_imminent_asteroid_speed, double __pyx_v_imminent_asteroid_relative_heading, double __pyx_v_largest_gap_relative_heading, double __pyx_v_nearby_asteroid_average_speed, PyObject *__pyx_v_nearby_asteroid_count) {
  PyObject *__pyx_v_maneuver_fis = NULL;
  PyObject *__pyx_v_acceleration_turn_rate = NULL;
  PyObject *__pyx_v_cruise_speed = NULL;
  PyObject *__pyx_v_cruise_turn_rate = NULL;
  PyObject *__pyx_v_cruise_timesteps = NULL;
  PyObject *__pyx_v_thrust_direction = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.maneuver_heuristic_fis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_maneuver_fis);
  __Pyx_XDECREF(__pyx_v_acceleration_turn_rate);
  __Pyx_XDECREF(__pyx_v_cruise_speed);
  __Pyx_XDECREF(__pyx_v_cruise_turn_rate);
  __Pyx_XDECREF(__pyx_v_cruise_timesteps);
  __Pyx_XDECREF(__pyx_v_thrust_direction);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_imminent_asteroid_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1906, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_imminent_asteroid_relative_headi, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1906, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_largest_gap_relative_heading, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1906, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_nearby_asteroid_average_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1906, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_nearby_asteroid_count, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 1906, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float_float_float_fl_2) < 0) __PYX_ERR(0, 1906, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_53maneuver_heuristic_fis, 0, __pyx_mstate_global->__pyx_n_u_maneuver_heuristic_fis, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[96])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_maneuver_heuristic_fis, __pyx_t_4) < 0) __PYX_ERR(0, 1906, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
struct __pyx_ctuple_double__and_double__and_double__and_double__and_double {
  double f0;
  double f1;
  double f2;
  double f3;
  double f4;
};

+1907:     maneuver_fis = setup_heuristic_maneuver_fis()

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_setup_heuristic_maneuver_fis); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1907, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1907, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_maneuver_fis = __pyx_t_1;
  __pyx_t_1 = 0;

 1908:     # print(f"imminent_asteroid_speed: {imminent_asteroid_speed}, imminent_asteroid_relative_heading: {imminent_asteroid_relative_heading}, largest_gap_relative_heading: {largest_gap_relative_heading}, nearby_asteroid_average_speed: {nearby_asteroid_average_speed}, nearby_asteroid_count: {nearby_asteroid_count}")

+1909:     maneuver_fis.input['imminent_asteroid_speed'] = imminent_asteroid_speed

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_imminent_asteroid_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1909, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1909, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_imminent_asteroid_speed, __pyx_t_1) < 0))) __PYX_ERR(0, 1909, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1910:     maneuver_fis.input['imminent_asteroid_relative_heading'] = imminent_asteroid_relative_heading

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_imminent_asteroid_relative_heading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1910, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1910, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_imminent_asteroid_relative_headi, __pyx_t_1) < 0))) __PYX_ERR(0, 1910, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1911:     maneuver_fis.input['largest_gap_relative_heading'] = largest_gap_relative_heading

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_largest_gap_relative_heading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_largest_gap_relative_heading, __pyx_t_1) < 0))) __PYX_ERR(0, 1911, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1912:     maneuver_fis.input['nearby_asteroid_average_speed'] = nearby_asteroid_average_speed

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_nearby_asteroid_average_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_nearby_asteroid_average_speed, __pyx_t_1) < 0))) __PYX_ERR(0, 1912, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1913:     maneuver_fis.input['nearby_asteroid_count'] = nearby_asteroid_count

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_input); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1913, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_nearby_asteroid_count, __pyx_v_nearby_asteroid_count) < 0))) __PYX_ERR(0, 1913, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1914:     maneuver_fis.compute()

  __pyx_t_3 = __pyx_v_maneuver_fis;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_compute, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1914, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1915: 

+1916:     acceleration_turn_rate = cast(float, maneuver_fis.output['ship_accel_turn_rate'])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_output); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_accel_turn_rate); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, ((PyObject *)(&PyFloat_Type)), __pyx_t_6};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1916, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_acceleration_turn_rate = __pyx_t_1;
  __pyx_t_1 = 0;

+1917:     cruise_speed = cast(float, maneuver_fis.output['ship_cruise_speed'])

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_output); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_cruise_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, ((PyObject *)(&PyFloat_Type)), __pyx_t_5};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1917, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_cruise_speed = __pyx_t_1;
  __pyx_t_1 = 0;

+1918:     cruise_turn_rate = cast(float, maneuver_fis.output['ship_cruise_turn_rate'])

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_output); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_cruise_turn_rate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_6, ((PyObject *)(&PyFloat_Type)), __pyx_t_3};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1918, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_cruise_turn_rate = __pyx_t_1;
  __pyx_t_1 = 0;

+1919:     cruise_timesteps = cast(float, maneuver_fis.output['ship_cruise_timesteps'])

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1919, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_output); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1919, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ship_cruise_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1919, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_5, ((PyObject *)(&PyFloat_Type)), __pyx_t_2};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1919, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_cruise_timesteps = __pyx_t_1;
  __pyx_t_1 = 0;

+1920:     thrust_direction = cast(float, maneuver_fis.output['ship_thrust_direction'])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1920, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_maneuver_fis, __pyx_mstate_global->__pyx_n_u_output); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1920, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_thrust_direction); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1920, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, ((PyObject *)(&PyFloat_Type)), __pyx_t_6};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1920, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_thrust_direction = __pyx_t_1;
  __pyx_t_1 = 0;

 1921:     # debug_print(f"FIS Acceleration Turn Rate: {acceleration_turn_rate}, Cruise Speed: {cruise_speed}, Cruise Turn Rate: {cruise_turn_rate}, Cruise Timesteps: {cruise_timesteps}, Thrust Direction: {thrust_direction}")

+1922:     return acceleration_turn_rate, cruise_speed, cruise_turn_rate, cruise_timesteps, thrust_direction

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1922, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_v_acceleration_turn_rate);
  __Pyx_GIVEREF(__pyx_v_acceleration_turn_rate);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_acceleration_turn_rate) != (0)) __PYX_ERR(0, 1922, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_cruise_speed);
  __Pyx_GIVEREF(__pyx_v_cruise_speed);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_cruise_speed) != (0)) __PYX_ERR(0, 1922, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_cruise_turn_rate);
  __Pyx_GIVEREF(__pyx_v_cruise_turn_rate);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_cruise_turn_rate) != (0)) __PYX_ERR(0, 1922, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_cruise_timesteps);
  __Pyx_GIVEREF(__pyx_v_cruise_timesteps);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_cruise_timesteps) != (0)) __PYX_ERR(0, 1922, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_thrust_direction);
  __Pyx_GIVEREF(__pyx_v_thrust_direction);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_v_thrust_direction) != (0)) __PYX_ERR(0, 1922, __pyx_L1_error);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1923: 

 1924: 

+1925: def sigmoid(x: float, k: float = 1.0, x0: float = 0.0) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_55sigmoid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_54sigmoid, "\n    Compute the logistic sigmoid function with scaling and shift.\n\n    Parameters:\n    - x: The input value or array of values.\n    - k: The scaling factor for steepness. Higher values make the curve steeper. Positive k makes an increasing function, while negative k make a decreasing function.\n    - x0: The shift factor. Positive values shift the curve to the right, negative to the left.\n\n    Returns:\n    - The logistic sigmoid function value(s) for the given input.\n    ");
static PyMethodDef __pyx_mdef_14neo_controller_55sigmoid = {"sigmoid", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_55sigmoid, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_54sigmoid};
static PyObject *__pyx_pw_14neo_controller_55sigmoid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  double __pyx_v_k;
  double __pyx_v_x0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sigmoid (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_k,&__pyx_mstate_global->__pyx_n_u_x0,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1925, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1925, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1925, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1925, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "sigmoid", 0) < 0) __PYX_ERR(0, 1925, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("sigmoid", 0, 1, 3, i); __PYX_ERR(0, 1925, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1925, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1925, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1925, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1925, __pyx_L3_error)
    if (values[1]) {
      __pyx_v_k = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_k == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1925, __pyx_L3_error)
    } else {
      __pyx_v_k = ((double)((double)1.0));
    }
    if (values[2]) {
      __pyx_v_x0 = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_x0 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1925, __pyx_L3_error)
    } else {
      __pyx_v_x0 = ((double)((double)0.0));
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("sigmoid", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1925, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.sigmoid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_54sigmoid(__pyx_self, __pyx_v_x, __pyx_v_k, __pyx_v_x0);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_54sigmoid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x, double __pyx_v_k, double __pyx_v_x0) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.sigmoid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = PyFloat_FromDouble(((double)1.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_9 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_2 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1925, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_k, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1925, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_x0, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1925, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1925, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_55sigmoid, 0, __pyx_mstate_global->__pyx_n_u_sigmoid, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[97])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_sigmoid, __pyx_t_4) < 0) __PYX_ERR(0, 1925, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1926:     """

 1927:     Compute the logistic sigmoid function with scaling and shift.

 1928: 

 1929:     Parameters:

 1930:     - x: The input value or array of values.

 1931:     - k: The scaling factor for steepness. Higher values make the curve steeper. Positive k makes an increasing function, while negative k make a decreasing function.

 1932:     - x0: The shift factor. Positive values shift the curve to the right, negative to the left.

 1933: 

 1934:     Returns:

 1935:     - The logistic sigmoid function value(s) for the given input.

 1936:     """

+1937:     return 1.0/(1.0 + exp(-k*(x - x0)))

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = (1.0 + exp(((-__pyx_v_k) * (__pyx_v_x - __pyx_v_x0))));
  if (unlikely(__pyx_t_1 == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 1937, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble((1.0 / __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1937, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1938: 

 1939: 

+1940: def linear(x: float, point1: tuple[float, float], point2: tuple[float, float]) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_57linear(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_56linear, "\n    Interpolate a linear function between two points. If the input is outside the range, then the output is clamped to the nearest extreme output.\n    ");
static PyMethodDef __pyx_mdef_14neo_controller_57linear = {"linear", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_57linear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_56linear};
static PyObject *__pyx_pw_14neo_controller_57linear(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_x;
  __pyx_ctuple_double__and_double __pyx_v_point1;
  __pyx_ctuple_double__and_double __pyx_v_point2;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("linear (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_point1,&__pyx_mstate_global->__pyx_n_u_point2,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1940, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1940, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1940, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1940, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "linear", 0) < 0) __PYX_ERR(0, 1940, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("linear", 1, 3, 3, i); __PYX_ERR(0, 1940, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1940, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1940, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1940, __pyx_L3_error)
    }
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1940, __pyx_L3_error)
    __pyx_v_point1 = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1940, __pyx_L3_error)
    __pyx_v_point2 = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[2]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1940, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("linear", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1940, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.linear", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_56linear(__pyx_self, __pyx_v_x, __pyx_v_point1, __pyx_v_point2);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_56linear(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x, __pyx_ctuple_double__and_double __pyx_v_point1, __pyx_ctuple_double__and_double __pyx_v_point2) {
  double __pyx_v_x1;
  double __pyx_v_y1;
  double __pyx_v_x2;
  double __pyx_v_y2;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.linear", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1940, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_point1, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1940, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_point2, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 1940, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1940, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_57linear, 0, __pyx_mstate_global->__pyx_n_u_linear, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[98])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_linear, __pyx_t_9) < 0) __PYX_ERR(0, 1940, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 1941:     """

 1942:     Interpolate a linear function between two points. If the input is outside the range, then the output is clamped to the nearest extreme output.

 1943:     """

+1944:     x1, y1 = point1

  __pyx_t_1 = __pyx_v_point1;
  __pyx_t_2 = __pyx_t_1.f0;
  __pyx_t_3 = __pyx_t_1.f1;
  __pyx_v_x1 = __pyx_t_2;
  __pyx_v_y1 = __pyx_t_3;

+1945:     x2, y2 = point2

  __pyx_t_1 = __pyx_v_point2;
  __pyx_t_3 = __pyx_t_1.f0;
  __pyx_t_2 = __pyx_t_1.f1;
  __pyx_v_x2 = __pyx_t_3;
  __pyx_v_y2 = __pyx_t_2;

+1946:     assert x1 < x2  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_4 = (__pyx_v_x1 < __pyx_v_x2);
    if (unlikely(!__pyx_t_4)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 1946, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 1946, __pyx_L1_error)
  #endif

+1947:     if x <= x1:

  __pyx_t_4 = (__pyx_v_x <= __pyx_v_x1);
  if (__pyx_t_4) {
/* … */
  }

+1948:         return y1

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1948, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_r = __pyx_t_5;
    __pyx_t_5 = 0;
    goto __pyx_L0;

+1949:     elif x >= x2:

  __pyx_t_4 = (__pyx_v_x >= __pyx_v_x2);
  if (__pyx_t_4) {
/* … */
  }

+1950:         return y2

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1950, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_r = __pyx_t_5;
    __pyx_t_5 = 0;
    goto __pyx_L0;

 1951:     else:

+1952:         return y1 + (x - x1)*(y2 - y1)/(x2 - x1)

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = ((__pyx_v_x - __pyx_v_x1) * (__pyx_v_y2 - __pyx_v_y1));
    __pyx_t_3 = (__pyx_v_x2 - __pyx_v_x1);
    if (unlikely(__pyx_t_3 == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 1952, __pyx_L1_error)
    }
    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_y1 + (__pyx_t_2 / __pyx_t_3))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1952, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_r = __pyx_t_5;
    __pyx_t_5 = 0;
    goto __pyx_L0;
  }

 1953: 

 1954: 

+1955: def weighted_average(numbers: Sequence[float | int], weights: Optional[Sequence[float | int]] = None) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_59weighted_average(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_58weighted_average, "\n    Calculate the weighted average of a list of numbers.\n    If no weights are provided, the regular average is calculated.\n    Raises ValueError if weights are provided but do not match the length of numbers.\n\n    Parameters:\n    - numbers: list of numbers.\n    - weights: Corresponding weights for each number.\n\n    Returns:\n    - The weighted (or regular) average of the numbers.\n\n    Raises:\n    - ValueError: If weights are provided but their length doesn't match the numbers list.\n    ");
static PyMethodDef __pyx_mdef_14neo_controller_59weighted_average = {"weighted_average", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_59weighted_average, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_58weighted_average};
static PyObject *__pyx_pw_14neo_controller_59weighted_average(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_numbers = 0;
  PyObject *__pyx_v_weights = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("weighted_average (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_numbers,&__pyx_mstate_global->__pyx_n_u_weights,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1955, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1955, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1955, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "weighted_average", 0) < 0) __PYX_ERR(0, 1955, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("weighted_average", 0, 1, 2, i); __PYX_ERR(0, 1955, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1955, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1955, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_numbers = values[0];
    __pyx_v_weights = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("weighted_average", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1955, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.weighted_average", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_58weighted_average(__pyx_self, __pyx_v_numbers, __pyx_v_weights);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_14neo_controller_16weighted_average_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
static PyObject *__pyx_pf_14neo_controller_58weighted_average(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_numbers, PyObject *__pyx_v_weights) {
  PyObject *__pyx_v_total_weighted = NULL;
  PyObject *__pyx_v_total_weight = NULL;
  PyObject *__pyx_gb_14neo_controller_16weighted_average_2generator3 = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.weighted_average", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_total_weighted);
  __Pyx_XDECREF(__pyx_v_total_weight);
  __Pyx_XDECREF(__pyx_gb_14neo_controller_16weighted_average_2generator3);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1955, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_numbers, __pyx_mstate_global->__pyx_kp_u_Sequence_float_int) < 0) __PYX_ERR(0, 1955, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_weights, __pyx_mstate_global->__pyx_kp_u_Optional_Sequence_float_int) < 0) __PYX_ERR(0, 1955, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1955, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_59weighted_average, 0, __pyx_mstate_global->__pyx_n_u_weighted_average, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[99])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1955, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[89]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_weighted_average, __pyx_t_4) < 0) __PYX_ERR(0, 1955, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[89] = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[89])) __PYX_ERR(0, 1955, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[89]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[89]);

 1956:     """

 1957:     Calculate the weighted average of a list of numbers.

 1958:     If no weights are provided, the regular average is calculated.

 1959:     Raises ValueError if weights are provided but do not match the length of numbers.

 1960: 

 1961:     Parameters:

 1962:     - numbers: list of numbers.

 1963:     - weights: Corresponding weights for each number.

 1964: 

 1965:     Returns:

 1966:     - The weighted (or regular) average of the numbers.

 1967: 

 1968:     Raises:

 1969:     - ValueError: If weights are provided but their length doesn't match the numbers list.

 1970:     """

+1971:     if weights is not None:

  __pyx_t_1 = (__pyx_v_weights != Py_None);
  if (__pyx_t_1) {
/* … */
  }

+1972:         if len(weights) != len(numbers):

    __pyx_t_2 = PyObject_Length(__pyx_v_weights); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1972, __pyx_L1_error)
    __pyx_t_3 = PyObject_Length(__pyx_v_numbers); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1972, __pyx_L1_error)
    __pyx_t_1 = (__pyx_t_2 != __pyx_t_3);
    if (unlikely(__pyx_t_1)) {
/* … */
    }

+1973:             raise ValueError("Length of weights must match length of numbers.")

      __pyx_t_5 = NULL;
      __Pyx_INCREF(__pyx_builtin_ValueError);
      __pyx_t_6 = __pyx_builtin_ValueError; 
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_Length_of_weights_must_match_len};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1973, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __PYX_ERR(0, 1973, __pyx_L1_error)

 1974:         # Calculate weighted average

+1975:         total_weighted = sum(float(number)*float(weight) for number, weight in zip(numbers, weights))

static PyObject *__pyx_pf_14neo_controller_16weighted_average_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_3_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_3_genexpr *)__pyx_tp_new_14neo_controller___pyx_scope_struct_3_genexpr(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_3_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_3_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 1975, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_14neo_controller_16weighted_average_2generator3, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_weighted_average_locals_genexpr, __pyx_mstate_global->__pyx_n_u_neo_controller); if (unlikely(!gen)) __PYX_ERR(0, 1975, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.weighted_average.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_14neo_controller_16weighted_average_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(0, 1975, __pyx_L1_error)
  }
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 1975, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1975, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1975, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1975, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1975, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1975, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1975, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
      PyObject* sequence = __pyx_t_4;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 1975, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_6);
      } else {
        __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1975, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_5);
        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1975, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_6);
      }
      #else
      __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1975, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1975, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      #endif
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1975, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7);
      index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_5);
      index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 1975, __pyx_L1_error)
      __pyx_t_8 = NULL;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      goto __pyx_L7_unpacking_done;
      __pyx_L6_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 1975, __pyx_L1_error)
      __pyx_L7_unpacking_done:;
    }
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_number);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_number, __pyx_t_5);
    __Pyx_GIVEREF(__pyx_t_5);
    __pyx_t_5 = 0;
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_weight);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_weight, __pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_6);
    __pyx_t_6 = 0;
    __pyx_t_9 = __Pyx_PyObject_AsDouble(__pyx_cur_scope->__pyx_v_number); if (unlikely(__pyx_t_9 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1975, __pyx_L1_error)
    __pyx_t_10 = __Pyx_PyObject_AsDouble(__pyx_cur_scope->__pyx_v_weight); if (unlikely(__pyx_t_10 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1975, __pyx_L1_error)
    __pyx_t_4 = PyFloat_FromDouble((__pyx_t_9 * __pyx_t_10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1975, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    __Pyx_XGIVEREF(__pyx_t_1);
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
    __pyx_cur_scope->__pyx_t_1 = __pyx_t_2;
    __pyx_cur_scope->__pyx_t_2 = __pyx_t_3;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L8_resume_from_yield:;
    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
    __pyx_cur_scope->__pyx_t_0 = 0;
    __Pyx_XGOTREF(__pyx_t_1);
    __pyx_t_2 = __pyx_cur_scope->__pyx_t_1;
    __pyx_t_3 = __pyx_cur_scope->__pyx_t_2;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1975, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
    __pyx_t_6 = NULL;
    __Pyx_INCREF(__pyx_builtin_sum);
    __pyx_t_5 = __pyx_builtin_sum; 
    __pyx_t_9 = NULL;
    __Pyx_INCREF(__pyx_builtin_zip);
    __pyx_t_10 = __pyx_builtin_zip; 
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_v_numbers, __pyx_v_weights};
      __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1975, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
    }
    __pyx_t_10 = __pyx_pf_14neo_controller_16weighted_average_genexpr(NULL, __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1975, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_10};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1975, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_total_weighted = __pyx_t_4;
    __pyx_t_4 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_3_genexpr {
  PyObject_HEAD
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_number;
  PyObject *__pyx_v_weight;
  PyObject *__pyx_t_0;
  Py_ssize_t __pyx_t_1;
  PyObject *(*__pyx_t_2)(PyObject *);
};

+1976:         total_weight = sum(weights)

    __pyx_t_5 = NULL;
    __Pyx_INCREF(__pyx_builtin_sum);
    __pyx_t_10 = __pyx_builtin_sum; 
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_weights};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1976, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_total_weight = __pyx_t_4;
    __pyx_t_4 = 0;

+1977:         return float(total_weighted)/float(total_weight)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_11 = __Pyx_PyObject_AsDouble(__pyx_v_total_weighted); if (unlikely(__pyx_t_11 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error)
    __pyx_t_12 = __Pyx_PyObject_AsDouble(__pyx_v_total_weight); if (unlikely(__pyx_t_12 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error)
    if (unlikely(__pyx_t_12 == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 1977, __pyx_L1_error)
    }
    __pyx_t_4 = PyFloat_FromDouble((__pyx_t_11 / __pyx_t_12)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1977, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 1978:     else:

 1979:         # Calculate regular average if no weights are provided

+1980:         return sum(numbers)/len(numbers) if numbers else 0.0

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_numbers); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1980, __pyx_L1_error)
    if (__pyx_t_1) {
      __pyx_t_5 = NULL;
      __Pyx_INCREF(__pyx_builtin_sum);
      __pyx_t_6 = __pyx_builtin_sum; 
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_numbers};
        __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1980, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      __pyx_t_3 = PyObject_Length(__pyx_v_numbers); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1980, __pyx_L1_error)
      __pyx_t_6 = PyLong_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1980, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_10, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1980, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_4 = __pyx_t_5;
      __pyx_t_5 = 0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __pyx_t_4 = __pyx_mstate_global->__pyx_float_0_0;
    }
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;
  }

 1981: 

 1982: 

+1983: def weighted_harmonic_mean(numbers: Sequence[float], weights: Optional[Sequence[float]] = None, offset: float = 0.0) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_61weighted_harmonic_mean(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_60weighted_harmonic_mean, "\n    Calculate the weighted harmonic mean of a list of numbers.\n    If no weights are provided, the regular harmonic mean is calculated.\n    Raises ValueError if weights are provided but do not match the length of numbers.\n\n    Parameters:\n    - numbers: list of numbers.\n    - weights: Corresponding weights for each number.\n\n    Returns:\n    - The weighted (or regular) harmonic mean of the numbers.\n\n    Raises:\n    - ValueError: If weights are provided but their length doesn't match the numbers list.\n    ");
static PyMethodDef __pyx_mdef_14neo_controller_61weighted_harmonic_mean = {"weighted_harmonic_mean", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_61weighted_harmonic_mean, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_60weighted_harmonic_mean};
static PyObject *__pyx_pw_14neo_controller_61weighted_harmonic_mean(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_numbers = 0;
  PyObject *__pyx_v_weights = 0;
  double __pyx_v_offset;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("weighted_harmonic_mean (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_numbers,&__pyx_mstate_global->__pyx_n_u_weights,&__pyx_mstate_global->__pyx_n_u_offset,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1983, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1983, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1983, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1983, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "weighted_harmonic_mean", 0) < 0) __PYX_ERR(0, 1983, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("weighted_harmonic_mean", 0, 1, 3, i); __PYX_ERR(0, 1983, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1983, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1983, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1983, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_numbers = values[0];
    __pyx_v_weights = values[1];
    if (values[2]) {
      __pyx_v_offset = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_offset == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1983, __pyx_L3_error)
    } else {
      __pyx_v_offset = ((double)((double)0.0));
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("weighted_harmonic_mean", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1983, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.weighted_harmonic_mean", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_60weighted_harmonic_mean(__pyx_self, __pyx_v_numbers, __pyx_v_weights, __pyx_v_offset);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_14neo_controller_22weighted_harmonic_mean_2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
static PyObject *__pyx_pf_14neo_controller_60weighted_harmonic_mean(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_numbers, PyObject *__pyx_v_weights, double __pyx_v_offset) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean *__pyx_cur_scope;
  PyObject *__pyx_v_weight_sum = NULL;
  PyObject *__pyx_v_weighted_reciprocals_sum = NULL;
  PyObject *__pyx_v_weighted_harmonic_mean = NULL;
  PyObject *__pyx_gb_14neo_controller_22weighted_harmonic_mean_2generator4 = 0;
  PyObject *__pyx_gb_14neo_controller_22weighted_harmonic_mean_5generator5 = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean *)__pyx_tp_new_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 1983, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_offset = __pyx_v_offset;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.weighted_harmonic_mean", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_weight_sum);
  __Pyx_XDECREF(__pyx_v_weighted_reciprocals_sum);
  __Pyx_XDECREF(__pyx_v_weighted_harmonic_mean);
  __Pyx_XDECREF(__pyx_gb_14neo_controller_22weighted_harmonic_mean_2generator4);
  __Pyx_XDECREF(__pyx_gb_14neo_controller_22weighted_harmonic_mean_5generator5);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_9 = PyTuple_Pack(2, Py_None, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_numbers, __pyx_mstate_global->__pyx_kp_u_Sequence_float) < 0) __PYX_ERR(0, 1983, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_weights, __pyx_mstate_global->__pyx_kp_u_Optional_Sequence_float) < 0) __PYX_ERR(0, 1983, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_offset, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1983, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 1983, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_61weighted_harmonic_mean, 0, __pyx_mstate_global->__pyx_n_u_weighted_harmonic_mean, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_weighted_harmonic_mean, __pyx_t_2) < 0) __PYX_ERR(0, 1983, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean {
  PyObject_HEAD
  double __pyx_v_offset;
};

 1984:     """

 1985:     Calculate the weighted harmonic mean of a list of numbers.

 1986:     If no weights are provided, the regular harmonic mean is calculated.

 1987:     Raises ValueError if weights are provided but do not match the length of numbers.

 1988: 

 1989:     Parameters:

 1990:     - numbers: list of numbers.

 1991:     - weights: Corresponding weights for each number.

 1992: 

 1993:     Returns:

 1994:     - The weighted (or regular) harmonic mean of the numbers.

 1995: 

 1996:     Raises:

 1997:     - ValueError: If weights are provided but their length doesn't match the numbers list.

 1998:     """

+1999:     if numbers:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_numbers); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1999, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+2000:         if weights is not None:

    __pyx_t_1 = (__pyx_v_weights != Py_None);
    if (__pyx_t_1) {
/* … */
    }

+2001:             if len(weights) != len(numbers):

      __pyx_t_2 = PyObject_Length(__pyx_v_weights); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2001, __pyx_L1_error)
      __pyx_t_3 = PyObject_Length(__pyx_v_numbers); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2001, __pyx_L1_error)
      __pyx_t_1 = (__pyx_t_2 != __pyx_t_3);
      if (unlikely(__pyx_t_1)) {
/* … */
      }

+2002:                 raise ValueError("Length of weights must match length of numbers.")

        __pyx_t_5 = NULL;
        __Pyx_INCREF(__pyx_builtin_ValueError);
        __pyx_t_6 = __pyx_builtin_ValueError; 
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_Length_of_weights_must_match_len};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2002, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __PYX_ERR(0, 2002, __pyx_L1_error)

 2003:             # Calculate weighted harmonic mean

+2004:             weight_sum = sum(weights)

      __pyx_t_6 = NULL;
      __Pyx_INCREF(__pyx_builtin_sum);
      __pyx_t_5 = __pyx_builtin_sum; 
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_weights};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2004, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_v_weight_sum = __pyx_t_4;
      __pyx_t_4 = 0;

+2005:             weighted_reciprocals_sum = sum(w/max(x + offset, TAD) for w, x in zip(weights, numbers))

static PyObject *__pyx_pf_14neo_controller_22weighted_harmonic_mean_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_5_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_5_genexpr *)__pyx_tp_new_14neo_controller___pyx_scope_struct_5_genexpr(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_5_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_5_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 2005, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean *) __pyx_self;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_14neo_controller_22weighted_harmonic_mean_2generator4, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_weighted_harmonic_mean_locals_ge, __pyx_mstate_global->__pyx_n_u_neo_controller); if (unlikely(!gen)) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.weighted_harmonic_mean.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_14neo_controller_22weighted_harmonic_mean_2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(0, 2005, __pyx_L1_error)
  }
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 2005, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2005, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2005, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2005, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2005, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2005, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
      PyObject* sequence = __pyx_t_4;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 2005, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_6);
      } else {
        __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2005, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_5);
        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2005, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_6);
      }
      #else
      __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      #endif
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7);
      index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_5);
      index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 2005, __pyx_L1_error)
      __pyx_t_8 = NULL;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      goto __pyx_L7_unpacking_done;
      __pyx_L6_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 2005, __pyx_L1_error)
      __pyx_L7_unpacking_done:;
    }
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_w);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_w, __pyx_t_5);
    __Pyx_GIVEREF(__pyx_t_5);
    __pyx_t_5 = 0;
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_x);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_x, __pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_6);
    __pyx_t_6 = 0;
    __pyx_t_9 = __pyx_v_14neo_controller_TAD;
    __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_offset); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = PyNumber_Add(__pyx_cur_scope->__pyx_v_x, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = PyFloat_FromDouble(__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_5, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_10) {
      __pyx_t_7 = PyFloat_FromDouble(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_4 = __pyx_t_7;
      __pyx_t_7 = 0;
    } else {
      __Pyx_INCREF(__pyx_t_6);
      __pyx_t_4 = __pyx_t_6;
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_cur_scope->__pyx_v_w, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2005, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_r = __pyx_t_6;
    __pyx_t_6 = 0;
    __Pyx_XGIVEREF(__pyx_t_1);
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
    __pyx_cur_scope->__pyx_t_1 = __pyx_t_2;
    __pyx_cur_scope->__pyx_t_2 = __pyx_t_3;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L8_resume_from_yield:;
    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
    __pyx_cur_scope->__pyx_t_0 = 0;
    __Pyx_XGOTREF(__pyx_t_1);
    __pyx_t_2 = __pyx_cur_scope->__pyx_t_1;
    __pyx_t_3 = __pyx_cur_scope->__pyx_t_2;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2005, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_14neo_controller_22weighted_harmonic_mean_5generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
      __pyx_t_5 = NULL;
      __Pyx_INCREF(__pyx_builtin_sum);
      __pyx_t_6 = __pyx_builtin_sum; 
      __pyx_t_9 = NULL;
      __Pyx_INCREF(__pyx_builtin_zip);
      __pyx_t_10 = __pyx_builtin_zip; 
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_v_weights, __pyx_v_numbers};
        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2005, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __pyx_t_10 = __pyx_pf_14neo_controller_22weighted_harmonic_mean_genexpr(((PyObject*)__pyx_cur_scope), __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_10};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2005, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_v_weighted_reciprocals_sum = __pyx_t_4;
      __pyx_t_4 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_5_genexpr {
  PyObject_HEAD
  struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean *__pyx_outer_scope;
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_w;
  PyObject *__pyx_v_x;
  PyObject *__pyx_t_0;
  Py_ssize_t __pyx_t_1;
  PyObject *(*__pyx_t_2)(PyObject *);
};

+2006:             weighted_harmonic_mean = weight_sum/weighted_reciprocals_sum - offset

      __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_weight_sum, __pyx_v_weighted_reciprocals_sum); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2006, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_offset); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2006, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = PyNumber_Subtract(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2006, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_v_weighted_harmonic_mean = __pyx_t_10;
      __pyx_t_10 = 0;

+2007:             return weighted_harmonic_mean  # Apparently without this redundant assignment of this variable, I get a compiler error in mypyc and it says I have an error on line -1 LOLL

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_v_weighted_harmonic_mean);
      __pyx_r = __pyx_v_weighted_harmonic_mean;
      goto __pyx_L0;

 2008:         else:

 2009:             # Calculate regular harmonic mean if no weights are provided

+2010:             weight_sum = len(numbers)

    /*else*/ {
      __pyx_t_3 = PyObject_Length(__pyx_v_numbers); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2010, __pyx_L1_error)
      __pyx_t_10 = PyLong_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2010, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_v_weight_sum = __pyx_t_10;
      __pyx_t_10 = 0;

+2011:             weighted_reciprocals_sum = sum(1.0/max(x + offset, TAD) for x in numbers)

static PyObject *__pyx_pf_14neo_controller_22weighted_harmonic_mean_3genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_6_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_6_genexpr *)__pyx_tp_new_14neo_controller___pyx_scope_struct_6_genexpr(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_6_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_6_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 2011, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean *) __pyx_self;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_14neo_controller_22weighted_harmonic_mean_5generator5, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_weighted_harmonic_mean_locals_ge, __pyx_mstate_global->__pyx_n_u_neo_controller); if (unlikely(!gen)) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.weighted_harmonic_mean.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_14neo_controller_22weighted_harmonic_mean_5generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(0, 2011, __pyx_L1_error)
  }
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 2011, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2011, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2011, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2011, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2011, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2011, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_x);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_x, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
    __pyx_t_5 = __pyx_v_14neo_controller_TAD;
    __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_offset); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = PyNumber_Add(__pyx_cur_scope->__pyx_v_x, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_7 = PyFloat_FromDouble(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_9) {
      __pyx_t_8 = PyFloat_FromDouble(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2011, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_4 = __pyx_t_8;
      __pyx_t_8 = 0;
    } else {
      __Pyx_INCREF(__pyx_t_6);
      __pyx_t_4 = __pyx_t_6;
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyFloat_TrueDivideCObj(__pyx_mstate_global->__pyx_float_1_0, __pyx_t_4, 1.0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2011, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_r = __pyx_t_6;
    __pyx_t_6 = 0;
    __Pyx_XGIVEREF(__pyx_t_1);
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
    __pyx_cur_scope->__pyx_t_1 = __pyx_t_2;
    __pyx_cur_scope->__pyx_t_2 = __pyx_t_3;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L6_resume_from_yield:;
    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
    __pyx_cur_scope->__pyx_t_0 = 0;
    __Pyx_XGOTREF(__pyx_t_1);
    __pyx_t_2 = __pyx_cur_scope->__pyx_t_1;
    __pyx_t_3 = __pyx_cur_scope->__pyx_t_2;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 2011, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
      __pyx_t_6 = NULL;
      __Pyx_INCREF(__pyx_builtin_sum);
      __pyx_t_4 = __pyx_builtin_sum; 
      __pyx_t_5 = __pyx_pf_14neo_controller_22weighted_harmonic_mean_3genexpr(((PyObject*)__pyx_cur_scope), __pyx_v_numbers); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2011, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5};
        __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2011, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      __pyx_v_weighted_reciprocals_sum = __pyx_t_10;
      __pyx_t_10 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_6_genexpr {
  PyObject_HEAD
  struct __pyx_obj_14neo_controller___pyx_scope_struct_4_weighted_harmonic_mean *__pyx_outer_scope;
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_x;
  PyObject *__pyx_t_0;
  Py_ssize_t __pyx_t_1;
  PyObject *(*__pyx_t_2)(PyObject *);
};

+2012:             weighted_harmonic_mean = weight_sum/weighted_reciprocals_sum - offset

      __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_v_weight_sum, __pyx_v_weighted_reciprocals_sum); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2012, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_offset); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2012, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = PyNumber_Subtract(__pyx_t_10, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2012, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_v_weighted_harmonic_mean = __pyx_t_5;
      __pyx_t_5 = 0;

+2013:             return weighted_harmonic_mean

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_v_weighted_harmonic_mean);
      __pyx_r = __pyx_v_weighted_harmonic_mean;
      goto __pyx_L0;
    }

 2014:     else:

+2015:         return 0.0

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
    goto __pyx_L0;
  }

 2016: 

 2017: 

+2018: def preprocess_bullets(bullets: list[Bullet]) -> list[Bullet]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_63preprocess_bullets(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_63preprocess_bullets = {"preprocess_bullets", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_63preprocess_bullets, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_63preprocess_bullets(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_bullets = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("preprocess_bullets (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_bullets,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2018, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2018, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "preprocess_bullets", 0) < 0) __PYX_ERR(0, 2018, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("preprocess_bullets", 1, 1, 1, i); __PYX_ERR(0, 2018, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2018, __pyx_L3_error)
    }
    __pyx_v_bullets = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("preprocess_bullets", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2018, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.preprocess_bullets", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bullets), (&PyList_Type), 0, "bullets", 2))) __PYX_ERR(0, 2018, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_62preprocess_bullets(__pyx_self, __pyx_v_bullets);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_62preprocess_bullets(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_bullets) {
  PyObject *__pyx_v_b = NULL;
  PyObject *__pyx_v_bullet_tail_delta = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.preprocess_bullets", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_b);
  __Pyx_XDECREF(__pyx_v_bullet_tail_delta);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2018, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_mstate_global->__pyx_kp_u_list_Bullet) < 0) __PYX_ERR(0, 2018, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Bullet) < 0) __PYX_ERR(0, 2018, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_63preprocess_bullets, 0, __pyx_mstate_global->__pyx_n_u_preprocess_bullets, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2018, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_preprocess_bullets, __pyx_t_4) < 0) __PYX_ERR(0, 2018, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2019:     for b in bullets:

  __pyx_t_1 = __pyx_v_bullets; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2019, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2019, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2020:         bullet_tail_delta = (-BULLET_LENGTH*cos(radians(b.heading)), -BULLET_LENGTH*sin(radians(b.heading)))

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyNumber_Negative(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_8 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_9 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_9 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyFloat_FromDouble(cos(__pyx_t_9)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyNumber_Negative(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_7 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_8 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_7);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_8 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_10};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_9 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_9 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyFloat_FromDouble(sin(__pyx_t_9)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_6);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 2020, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_5);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 2020, __pyx_L1_error);
    __pyx_t_6 = 0;
    __pyx_t_5 = 0;
    __Pyx_XDECREF_SET(__pyx_v_bullet_tail_delta, ((PyObject*)__pyx_t_3));
    __pyx_t_3 = 0;

+2021:         b.tail_delta = bullet_tail_delta

    if (__Pyx_PyObject_SetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_tail_delta, __pyx_v_bullet_tail_delta) < 0) __PYX_ERR(0, 2021, __pyx_L1_error)

+2022:     return bullets

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_bullets);
  __pyx_r = __pyx_v_bullets;
  goto __pyx_L0;

 2023: 

 2024: 

+2025: def preprocess_bullets_in_gamestate(game_state: GameState) -> GameState:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_GameState *__pyx_pw_14neo_controller_65preprocess_bullets_in_gamestate(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_65preprocess_bullets_in_gamestate = {"preprocess_bullets_in_gamestate", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_65preprocess_bullets_in_gamestate, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static struct __pyx_obj_14neo_controller_GameState *__pyx_pw_14neo_controller_65preprocess_bullets_in_gamestate(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_GameState *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("preprocess_bullets_in_gamestate (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2025, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2025, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "preprocess_bullets_in_gamestate", 0) < 0) __PYX_ERR(0, 2025, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("preprocess_bullets_in_gamestate", 1, 1, 1, i); __PYX_ERR(0, 2025, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2025, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("preprocess_bullets_in_gamestate", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2025, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.preprocess_bullets_in_gamestate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2025, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_64preprocess_bullets_in_gamestate(__pyx_self, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_GameState *__pyx_pf_14neo_controller_64preprocess_bullets_in_gamestate(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.preprocess_bullets_in_gamestate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2025, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2025, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2025, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_65preprocess_bullets_in_gamestate, 0, __pyx_mstate_global->__pyx_n_u_preprocess_bullets_in_gamestate, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[102])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2025, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_preprocess_bullets_in_gamestate, __pyx_t_2) < 0) __PYX_ERR(0, 2025, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2026:     # UNUSED

+2027:     game_state.bullets = preprocess_bullets(game_state.bullets)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_preprocess_bullets); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2027, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_game_state->bullets};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2027, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 2027, __pyx_L1_error)
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_game_state->bullets);
  __Pyx_DECREF(__pyx_v_game_state->bullets);
  __pyx_v_game_state->bullets = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2028:     return game_state

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_game_state);
  __pyx_r = __pyx_v_game_state;
  goto __pyx_L0;

 2029: 

 2030: 

+2031: def print_explanation(message: str, current_timestep: int) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_67print_explanation(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_67print_explanation = {"print_explanation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_67print_explanation, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_67print_explanation(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_message = 0;
  PyObject *__pyx_v_current_timestep = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("print_explanation (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_message,&__pyx_mstate_global->__pyx_n_u_current_timestep,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2031, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2031, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2031, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "print_explanation", 0) < 0) __PYX_ERR(0, 2031, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("print_explanation", 1, 2, 2, i); __PYX_ERR(0, 2031, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2031, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2031, __pyx_L3_error)
    }
    __pyx_v_message = ((PyObject*)values[0]);
    __pyx_v_current_timestep = ((PyObject*)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("print_explanation", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2031, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.print_explanation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_message), (&PyUnicode_Type), 0, "message", 2))) __PYX_ERR(0, 2031, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_current_timestep), (&PyLong_Type), 0, "current_timestep", 2))) __PYX_ERR(0, 2031, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_66print_explanation(__pyx_self, __pyx_v_message, __pyx_v_current_timestep);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_66print_explanation(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_message, PyObject *__pyx_v_current_timestep) {
  PyObject *__pyx_v_last_timestep_printed = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.print_explanation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_last_timestep_printed);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2031, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_message, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 2031, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2031, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2031, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_67print_explanation, 0, __pyx_mstate_global->__pyx_n_u_print_explanation, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[103])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2031, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_print_explanation, __pyx_t_4) < 0) __PYX_ERR(0, 2031, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2032:     if not PRINT_EXPLANATIONS:

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PRINT_EXPLANATIONS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2032, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2032, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = (!__pyx_t_2);
  if (__pyx_t_3) {
/* … */
  }

+2033:         return

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

 2034:     global explanation_messages_with_timestamps

 2035: 

 2036:     # Check if the message was printed within the time threshold

+2037:     last_timestep_printed = explanation_messages_with_timestamps.get(message, INT_NEG_INF)

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_explanation_messages_with_timest); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_message, __pyx_t_5};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2037, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_last_timestep_printed = __pyx_t_1;
  __pyx_t_1 = 0;

+2038:     if current_timestep - last_timestep_printed >= int(EXPLANATION_MESSAGE_SILENCE_INTERVAL_S*FPS):

  __pyx_t_1 = PyNumber_Subtract(__pyx_v_current_timestep, __pyx_v_last_timestep_printed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2038, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_EXPLANATION_MESSAGE_SILENCE_INTE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2038, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2038, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2038, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyNumber_Int(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2038, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_5, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2038, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 2038, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_3) {
/* … */
  }

+2039:         print(message)

    __pyx_t_5 = NULL;
    __Pyx_INCREF(__pyx_builtin_print);
    __pyx_t_1 = __pyx_builtin_print; 
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_message};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2039, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2040:         #log_explanation(message, current_timestep)

+2041:         explanation_messages_with_timestamps[message] = current_timestep

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_explanation_messages_with_timest); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2041, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_v_message, __pyx_v_current_timestep) < 0))) __PYX_ERR(0, 2041, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2042: 

 2043: 

+2044: def log_explanation(message: str, current_timestep: int, log_file: str = "Neo Explanations.txt") -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_69log_explanation(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_69log_explanation = {"log_explanation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_69log_explanation, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_69log_explanation(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_message = 0;
  PyObject *__pyx_v_current_timestep = 0;
  PyObject *__pyx_v_log_file = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("log_explanation (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_message,&__pyx_mstate_global->__pyx_n_u_current_timestep,&__pyx_mstate_global->__pyx_n_u_log_file,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2044, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2044, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2044, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2044, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "log_explanation", 0) < 0) __PYX_ERR(0, 2044, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_kp_u_Neo_Explanations_txt)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("log_explanation", 0, 2, 3, i); __PYX_ERR(0, 2044, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2044, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2044, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2044, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_kp_u_Neo_Explanations_txt)));
    }
    __pyx_v_message = ((PyObject*)values[0]);
    __pyx_v_current_timestep = ((PyObject*)values[1]);
    __pyx_v_log_file = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("log_explanation", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 2044, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.log_explanation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_message), (&PyUnicode_Type), 0, "message", 2))) __PYX_ERR(0, 2044, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_current_timestep), (&PyLong_Type), 0, "current_timestep", 2))) __PYX_ERR(0, 2044, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_log_file), (&PyUnicode_Type), 0, "log_file", 2))) __PYX_ERR(0, 2044, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_68log_explanation(__pyx_self, __pyx_v_message, __pyx_v_current_timestep, __pyx_v_log_file);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_68log_explanation(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_message, PyObject *__pyx_v_current_timestep, PyObject *__pyx_v_log_file) {
  PyObject *__pyx_v_file = NULL;
  PyObject *__pyx_v_e = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_AddTraceback("neo_controller.log_explanation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_file);
  __Pyx_XDECREF(__pyx_v_e);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2044, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_message, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 2044, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2044, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_log_file, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 2044, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2044, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_69log_explanation, 0, __pyx_mstate_global->__pyx_n_u_log_explanation, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[104])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2044, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[90]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_log_explanation, __pyx_t_2) < 0) __PYX_ERR(0, 2044, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[90] = PyTuple_Pack(1, ((PyObject*)__pyx_mstate_global->__pyx_kp_u_Neo_Explanations_txt)); if (unlikely(!__pyx_mstate_global->__pyx_tuple[90])) __PYX_ERR(0, 2044, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[90]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[90]);

+2045:     try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L4_exception_handled:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    __pyx_L8_try_end:;
  }

+2046:         with open(log_file, 'a') as file:

      /*with:*/ {
        __pyx_t_5 = NULL;
        __Pyx_INCREF(__pyx_builtin_open);
        __pyx_t_6 = __pyx_builtin_open; 
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_log_file, __pyx_mstate_global->__pyx_n_u_a};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2046, __pyx_L3_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2046, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_5 = NULL;
        __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2046, __pyx_L9_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_7 = 1;
        #if CYTHON_UNPACK_METHODS
        if (likely(PyMethod_Check(__pyx_t_9))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9);
          assert(__pyx_t_5);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
          __pyx_t_7 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
          __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2046, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_6);
        }
        __pyx_t_9 = __pyx_t_6;
        __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        /*try:*/ {
          {
            /*try:*/ {
              __pyx_v_file = __pyx_t_9;
              __pyx_t_9 = 0;
/* … */
            }
            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
            goto __pyx_L18_try_end;
            __pyx_L13_error:;
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
            /*except:*/ {
              __Pyx_AddTraceback("neo_controller.log_explanation", __pyx_clineno, __pyx_lineno, __pyx_filename);
              if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 2046, __pyx_L15_except_error)
              __Pyx_XGOTREF(__pyx_t_9);
              __Pyx_XGOTREF(__pyx_t_5);
              __Pyx_XGOTREF(__pyx_t_4);
              __pyx_t_6 = PyTuple_Pack(3, __pyx_t_9, __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2046, __pyx_L15_except_error)
              __Pyx_GOTREF(__pyx_t_6);
              __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_6, NULL);
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2046, __pyx_L15_except_error)
              __Pyx_GOTREF(__pyx_t_14);
              __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14);
              __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
              if (__pyx_t_15 < 0) __PYX_ERR(0, 2046, __pyx_L15_except_error)
              __pyx_t_16 = (!__pyx_t_15);
              if (unlikely(__pyx_t_16)) {
                __Pyx_GIVEREF(__pyx_t_9);
                __Pyx_GIVEREF(__pyx_t_5);
                __Pyx_XGIVEREF(__pyx_t_4);
                __Pyx_ErrRestoreWithState(__pyx_t_9, __pyx_t_5, __pyx_t_4);
                __pyx_t_9 = 0;  __pyx_t_5 = 0;  __pyx_t_4 = 0; 
                __PYX_ERR(0, 2046, __pyx_L15_except_error)
              }
              __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
              goto __pyx_L14_exception_handled;
            }
            __pyx_L15_except_error:;
            __Pyx_XGIVEREF(__pyx_t_10);
            __Pyx_XGIVEREF(__pyx_t_11);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
            goto __pyx_L3_error;
            __pyx_L14_exception_handled:;
            __Pyx_XGIVEREF(__pyx_t_10);
            __Pyx_XGIVEREF(__pyx_t_11);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
            __pyx_L18_try_end:;
          }
        }
        /*finally:*/ {
          /*normal exit:*/{
            if (__pyx_t_8) {
              __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_mstate_global->__pyx_tuple[9], NULL);
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2046, __pyx_L3_error)
              __Pyx_GOTREF(__pyx_t_12);
              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
            }
            goto __pyx_L12;
          }
          __pyx_L12:;
        }
        goto __pyx_L22;
        __pyx_L9_error:;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        goto __pyx_L3_error;
        __pyx_L22:;
      }
/* … */
  __pyx_mstate_global->__pyx_tuple[9] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[9])) __PYX_ERR(0, 2046, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[9]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[9]);

+2047:             file.write(f"Timestep {current_timestep} - {message}\n")

              __pyx_t_4 = __pyx_v_file;
              __Pyx_INCREF(__pyx_t_4);
              __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_current_timestep, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2047, __pyx_L13_error)
              __Pyx_GOTREF(__pyx_t_6);
              __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_Timestep;
              __pyx_t_13[1] = __pyx_t_6;
              __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u__11;
              __pyx_t_13[3] = __pyx_v_message;
              __pyx_t_13[4] = __pyx_mstate_global->__pyx_kp_u__12;
              __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_13, 5, 9 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 3 + __Pyx_PyUnicode_GET_LENGTH(__pyx_v_message) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_message));
              if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2047, __pyx_L13_error)
              __Pyx_GOTREF(__pyx_t_5);
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              __pyx_t_7 = 0;
              {
                PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5};
                __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2047, __pyx_L13_error)
                __Pyx_GOTREF(__pyx_t_9);
              }
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+2048:     except Exception as e:

    __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
    if (__pyx_t_17) {
      __Pyx_AddTraceback("neo_controller.log_explanation", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(0, 2048, __pyx_L5_except_error)
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_5);
      __pyx_v_e = __pyx_t_5;
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
          goto __pyx_L29;
        }
        __pyx_L28_error:;
        /*exception exit:*/{
          __Pyx_PyThreadState_declare
          __Pyx_PyThreadState_assign
          __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_14 = 0; __pyx_t_24 = 0;
          __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
          __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
           __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_14, &__pyx_t_24);
          if ( unlikely(__Pyx_GetException(&__pyx_t_8, &__pyx_t_12, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_8, &__pyx_t_12, &__pyx_t_11);
          __Pyx_XGOTREF(__pyx_t_8);
          __Pyx_XGOTREF(__pyx_t_12);
          __Pyx_XGOTREF(__pyx_t_11);
          __Pyx_XGOTREF(__pyx_t_10);
          __Pyx_XGOTREF(__pyx_t_14);
          __Pyx_XGOTREF(__pyx_t_24);
          __pyx_t_17 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_23 = __pyx_filename;
          {
            __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
          }
          __Pyx_XGIVEREF(__pyx_t_10);
          __Pyx_XGIVEREF(__pyx_t_14);
          __Pyx_XGIVEREF(__pyx_t_24);
          __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_14, __pyx_t_24);
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_XGIVEREF(__pyx_t_12);
          __Pyx_XGIVEREF(__pyx_t_11);
          __Pyx_ErrRestore(__pyx_t_8, __pyx_t_12, __pyx_t_11);
          __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_14 = 0; __pyx_t_24 = 0;
          __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_23;
          goto __pyx_L5_except_error;
        }
        __pyx_L29:;
      }
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      goto __pyx_L4_exception_handled;
    }
    goto __pyx_L5_except_error;

+2049:         print(f"Exception occurred when trying to log explanation: {e}")

        __pyx_t_18 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_19 = __pyx_builtin_print; 
        __pyx_t_20 = __Pyx_PyObject_FormatSimple(__pyx_v_e, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 2049, __pyx_L28_error)
        __Pyx_GOTREF(__pyx_t_20);
        __pyx_t_21 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Exception_occurred_when_trying_t, __pyx_t_20); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 2049, __pyx_L28_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_t_21};
          __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2049, __pyx_L28_error)
          __Pyx_GOTREF(__pyx_t_6);
        }
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      }

 2050: 

 2051: 

+2052: def debug_print(*messages: Any) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_71debug_print(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_71debug_print = {"debug_print", (PyCFunction)(void(*)(void))(PyCFunctionWithKeywords)__pyx_pw_14neo_controller_71debug_print, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_71debug_print(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_messages = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("debug_print (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return NULL;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("debug_print", __pyx_kwds); return NULL;}
  __Pyx_INCREF(__pyx_args);
  __pyx_v_messages = __pyx_args;
  __pyx_r = __pyx_pf_14neo_controller_70debug_print(__pyx_self, __pyx_v_messages);

  /* function exit code */
  __Pyx_DECREF(__pyx_v_messages);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_70debug_print(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_messages) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.debug_print", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_messages, __pyx_mstate_global->__pyx_n_u_Any) < 0) __PYX_ERR(0, 2052, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2052, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_71debug_print, 0, __pyx_mstate_global->__pyx_n_u_debug_print, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[105])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_debug_print, __pyx_t_4) < 0) __PYX_ERR(0, 2052, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2053:     if DEBUG_MODE:

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DEBUG_MODE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2053, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2053, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+2054:         print(*messages)

    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_v_messages, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2054, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 2055: 

 2056: 

+2057: def inspect_scenario(game_state: GameState, ship_state: Ship) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_73inspect_scenario(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_73inspect_scenario = {"inspect_scenario", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_73inspect_scenario, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_73inspect_scenario(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("inspect_scenario (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_ship_state,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2057, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2057, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2057, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "inspect_scenario", 0) < 0) __PYX_ERR(0, 2057, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("inspect_scenario", 1, 2, 2, i); __PYX_ERR(0, 2057, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2057, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2057, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("inspect_scenario", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2057, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.inspect_scenario", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2057, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 2057, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_72inspect_scenario(__pyx_self, __pyx_v_game_state, __pyx_v_ship_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_72inspect_scenario(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *__pyx_cur_scope;
  PyObject *__pyx_v_asteroids_count = NULL;
  PyObject *__pyx_v_current_count = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_asteroid_density = 0;
  CYTHON_UNUSED PyObject *__pyx_v_average_velocity = 0;
  CYTHON_UNUSED PyObject *__pyx_v_average_speed = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *)__pyx_tp_new_14neo_controller___pyx_scope_struct_7_inspect_scenario(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_7_inspect_scenario, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 2057, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.inspect_scenario", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_asteroids_count);
  __Pyx_XDECREF(__pyx_v_current_count);
  __Pyx_XDECREF(__pyx_v_asteroid_density);
  __Pyx_XDECREF(__pyx_v_average_velocity);
  __Pyx_XDECREF(__pyx_v_average_speed);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2057, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 2057, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2057, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_73inspect_scenario, 0, __pyx_mstate_global->__pyx_n_u_inspect_scenario, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[106])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_inspect_scenario, __pyx_t_2) < 0) __PYX_ERR(0, 2057, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario {
  PyObject_HEAD
  PyObject *__pyx_v_asteroids;
  PyObject *__pyx_v_height;
  PyObject *__pyx_v_width;
};

+2058:     asteroids = game_state.asteroids

  __pyx_t_1 = __pyx_v_game_state->asteroids;
  __Pyx_INCREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_asteroids = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2059:     width = game_state.map_size[0]

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_cur_scope->__pyx_v_width = __pyx_t_2;
  __pyx_t_2 = 0;

+2060:     height = game_state.map_size[1]

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2060, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2060, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_height = __pyx_t_1;
  __pyx_t_1 = 0;

+2061:     asteroids_count, current_count = asteroid_counter(asteroids)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_asteroid_counter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2061, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_asteroids};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2061, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 2061, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_2);
    } else {
      __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2061, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_3);
      __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2061, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_2);
    }
    #else
    __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2061, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2061, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2061, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5);
    index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 1; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 2061, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 2061, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_asteroids_count = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_current_count = __pyx_t_2;
  __pyx_t_2 = 0;

+2062:     if current_count == 0:

  __pyx_t_7 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_current_count, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2062, __pyx_L1_error)
  if (__pyx_t_7) {
/* … */
  }

+2063:         print_explanation("There's no asteroids on the screen! I'm lonely.", 0)

    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2063, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[11], NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2063, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[11] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u_There_s_no_asteroids_on_the_scre, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[11])) __PYX_ERR(0, 2063, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[11]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[11]);

+2064:         return

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

+2065:     print_explanation(f"The starting field has {current_count} asteroids on the screen, with a total of {asteroids_count} counting splits.", 0)

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2065, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_current_count, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2065, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_asteroids_count, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2065, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u_The_starting_field_has;
  __pyx_t_9[1] = __pyx_t_5;
  __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_asteroids_on_the_screen_with_a;
  __pyx_t_9[3] = __pyx_t_8;
  __pyx_t_9[4] = __pyx_mstate_global->__pyx_kp_u_counting_splits;
  __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_9, 5, 23 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 42 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 17, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8));
  if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2065, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_10, __pyx_mstate_global->__pyx_int_0};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2065, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2066:     print_explanation(f"At my max shot rate, it'll take {float(asteroids_count)*SHIP_FIRE_TIME:.01f} seconds to clear the field.", 0)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2066, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_1 = __Pyx_PyNumber_Float(__pyx_v_asteroids_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2066, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_FIRE_TIME); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2066, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2066, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Format(__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_01f); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2066, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_At_my_max_shot_rate_it_ll_take;
  __pyx_t_11[1] = __pyx_t_8;
  __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_seconds_to_clear_the_field;
  __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_11, 3, 32 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 28, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8));
  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2066, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_5, __pyx_mstate_global->__pyx_int_0};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2066, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2067:     if ship_state.bullets_remaining == -1:

  switch (__pyx_v_ship_state->bullets_remaining) {
    case -1L:
/* … */
    break;
    case 0:

+2068:         print_explanation(f"Yay I have unlimited bullets!", 0)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2068, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[12], NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2068, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[12] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u_Yay_I_have_unlimited_bullets, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[12])) __PYX_ERR(0, 2068, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[12]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[12]);

+2069:     elif ship_state.bullets_remaining == 0:

    break;
    default:

+2070:         print_explanation("Oh no, I haven't been given any bullets. I'll just hopefully put on a good show and dodge asteroids until the end of time.", 0)

    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2070, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_mstate_global->__pyx_tuple[13], NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2070, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[13] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u_Oh_no_I_haven_t_been_given_any_b, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[13])) __PYX_ERR(0, 2070, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[13]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[13]);

 2071:     else:

+2072:         print_explanation(f"Bullets are limited to letting me shoot {float(ship_state.bullets_remaining)/float(asteroids_count):.0%} of the asteroids. If there's another ship, I'll be careful not to let them steal my shots! Otherwise, I'll shoot away!", 0)

    __pyx_t_10 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2072, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_12 = __Pyx_PyObject_AsDouble(__pyx_v_asteroids_count); if (unlikely(__pyx_t_12 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2072, __pyx_L1_error)
    if (unlikely(__pyx_t_12 == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 2072, __pyx_L1_error)
    }
    __pyx_t_3 = PyFloat_FromDouble((((double)__pyx_v_ship_state->bullets_remaining) / __pyx_t_12)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2072, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = __Pyx_PyObject_Format(__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2072, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_Bullets_are_limited_to_letting_m;
    __pyx_t_11[1] = __pyx_t_8;
    __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_of_the_asteroids_If_there_s_ano;
    __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_11, 3, 40 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 119, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8));
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2072, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_4 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_10);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_4 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_3, __pyx_mstate_global->__pyx_int_0};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2072, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    break;
  }

 2073: 

+2074:     def asteroid_density() -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_16inspect_scenario_1asteroid_density(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_16inspect_scenario_1asteroid_density = {"asteroid_density", (PyCFunction)__pyx_pw_14neo_controller_16inspect_scenario_1asteroid_density, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_16inspect_scenario_1asteroid_density(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("asteroid_density (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_16inspect_scenario_asteroid_density(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_16inspect_scenario_asteroid_density(PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *__pyx_outer_scope;
  PyObject *__pyx_v_total_asteroid_coverage_area = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_total_screen_size = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.inspect_scenario.asteroid_density", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_total_asteroid_coverage_area);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_total_screen_size);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2074, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2074, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_16inspect_scenario_1asteroid_density, 0, __pyx_mstate_global->__pyx_n_u_inspect_scenario_locals_asteroid, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2074, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_asteroid_density = __pyx_t_5;
  __pyx_t_5 = 0;

+2075:         total_asteroid_coverage_area = 0.0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
  __pyx_v_total_asteroid_coverage_area = __pyx_mstate_global->__pyx_float_0_0;

+2076:         for a in asteroids:

  if (unlikely(!__pyx_cur_scope->__pyx_v_asteroids)) { __Pyx_RaiseClosureNameError("asteroids"); __PYX_ERR(0, 2076, __pyx_L1_error) }
  if (unlikely(__pyx_cur_scope->__pyx_v_asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2076, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_cur_scope->__pyx_v_asteroids; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2076, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2076, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2077:             total_asteroid_coverage_area += ASTEROID_AREA_LOOKUP[a.size]

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROID_AREA_LOOKUP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2077, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2077, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2077, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_total_asteroid_coverage_area, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2077, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF_SET(__pyx_v_total_asteroid_coverage_area, __pyx_t_4);
    __pyx_t_4 = 0;

+2078:         total_screen_size = width*height

  if (unlikely(!__pyx_cur_scope->__pyx_v_width)) { __Pyx_RaiseClosureNameError("width"); __PYX_ERR(0, 2078, __pyx_L1_error) }
  if (unlikely(!__pyx_cur_scope->__pyx_v_height)) { __Pyx_RaiseClosureNameError("height"); __PYX_ERR(0, 2078, __pyx_L1_error) }
  __pyx_t_1 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_width, __pyx_cur_scope->__pyx_v_height); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2078, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_total_screen_size = __pyx_t_1;
  __pyx_t_1 = 0;

+2079:         if total_screen_size == 0.0:

  __pyx_t_6 = (__Pyx_PyFloat_BoolEqObjC(__pyx_v_total_screen_size, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2079, __pyx_L1_error)
  if (__pyx_t_6) {
/* … */
  }

+2080:             return 0.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
    goto __pyx_L0;

 2081:         else:

+2082:             return total_asteroid_coverage_area/total_screen_size

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_v_total_asteroid_coverage_area, __pyx_v_total_screen_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2082, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

 2083: 

+2084:     def average_velocity() -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_16inspect_scenario_3average_velocity(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_16inspect_scenario_3average_velocity = {"average_velocity", (PyCFunction)__pyx_pw_14neo_controller_16inspect_scenario_3average_velocity, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_16inspect_scenario_3average_velocity(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("average_velocity (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_16inspect_scenario_2average_velocity(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_16inspect_scenario_2average_velocity(PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *__pyx_outer_scope;
  double __pyx_v_total_x_velocity;
  double __pyx_v_total_y_velocity;
  PyObject *__pyx_v_a = NULL;
  __pyx_ctuple_double__and_double __pyx_v_ast_vel;
  PyObject *__pyx_v_num_asteroids = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.inspect_scenario.average_velocity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_num_asteroids);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2084, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2084, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_16inspect_scenario_3average_velocity, 0, __pyx_mstate_global->__pyx_n_u_inspect_scenario_locals_average, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2084, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_average_velocity = __pyx_t_2;
  __pyx_t_2 = 0;

+2085:         total_x_velocity = 0.0

  __pyx_v_total_x_velocity = 0.0;

+2086:         total_y_velocity = 0.0

  __pyx_v_total_y_velocity = 0.0;

+2087:         for a in asteroids:

  if (unlikely(!__pyx_cur_scope->__pyx_v_asteroids)) { __Pyx_RaiseClosureNameError("asteroids"); __PYX_ERR(0, 2087, __pyx_L1_error) }
  if (unlikely(__pyx_cur_scope->__pyx_v_asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2087, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_cur_scope->__pyx_v_asteroids; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2087, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2087, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2088:             ast_vel: tuple[float, float] = a.velocity

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2088, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __pyx_convert__from_py___pyx_ctuple_double__and_double(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2088, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_ast_vel = __pyx_t_4;

+2089:             total_x_velocity += ast_vel[0]

    __pyx_v_total_x_velocity = (__pyx_v_total_x_velocity + __pyx_v_ast_vel.f0);

+2090:             total_y_velocity += ast_vel[1]

    __pyx_v_total_y_velocity = (__pyx_v_total_y_velocity + __pyx_v_ast_vel.f1);

+2091:         num_asteroids = len(asteroids)

  if (unlikely(!__pyx_cur_scope->__pyx_v_asteroids)) { __Pyx_RaiseClosureNameError("asteroids"); __PYX_ERR(0, 2091, __pyx_L1_error) }
  __pyx_t_1 = __pyx_cur_scope->__pyx_v_asteroids;
  __Pyx_INCREF(__pyx_t_1);
  if (unlikely(__pyx_t_1 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 2091, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2091, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2091, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_num_asteroids = __pyx_t_1;
  __pyx_t_1 = 0;

+2092:         if num_asteroids == 0:

  __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_num_asteroids, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 2092, __pyx_L1_error)
  if (__pyx_t_5) {
/* … */
  }

+2093:             return (0, 0)

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[10]);
    __pyx_r = __pyx_mstate_global->__pyx_tuple[10];
    goto __pyx_L0;
/* … */
  __pyx_mstate_global->__pyx_tuple[10] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[10])) __PYX_ERR(0, 2093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[10]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[10]);

 2094:         else:

+2095:             return (total_x_velocity/num_asteroids, total_y_velocity/num_asteroids)

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_total_x_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2095, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_v_num_asteroids); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2095, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_total_y_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2095, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_v_num_asteroids); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2095, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2095, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 2095, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_6);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2095, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_t_6 = 0;
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

 2096: 

+2097:     def average_speed() -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_16inspect_scenario_5average_speed(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_16inspect_scenario_5average_speed = {"average_speed", (PyCFunction)__pyx_pw_14neo_controller_16inspect_scenario_5average_speed, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_16inspect_scenario_5average_speed(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("average_speed (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_16inspect_scenario_4average_speed(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_16inspect_scenario_4average_speed(PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *__pyx_outer_scope;
  double __pyx_v_total_speed;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_num_asteroids = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_7_inspect_scenario *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.inspect_scenario.average_speed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_num_asteroids);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2097, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2097, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_16inspect_scenario_5average_speed, 0, __pyx_mstate_global->__pyx_n_u_inspect_scenario_locals_average_2, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2097, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_average_speed = __pyx_t_5;
  __pyx_t_5 = 0;

+2098:         total_speed = 0.0

  __pyx_v_total_speed = 0.0;

+2099:         for a in asteroids:

  if (unlikely(!__pyx_cur_scope->__pyx_v_asteroids)) { __Pyx_RaiseClosureNameError("asteroids"); __PYX_ERR(0, 2099, __pyx_L1_error) }
  if (unlikely(__pyx_cur_scope->__pyx_v_asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2099, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_cur_scope->__pyx_v_asteroids; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2099, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2099, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2100:             total_speed += sqrt(a.velocity[0]*a.velocity[0] + a.velocity[1]*a.velocity[1])

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Multiply(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyNumber_Add(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2100, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_v_total_speed = (__pyx_v_total_speed + sqrt(__pyx_t_7));

+2101:         num_asteroids = len(asteroids)

  if (unlikely(!__pyx_cur_scope->__pyx_v_asteroids)) { __Pyx_RaiseClosureNameError("asteroids"); __PYX_ERR(0, 2101, __pyx_L1_error) }
  __pyx_t_1 = __pyx_cur_scope->__pyx_v_asteroids;
  __Pyx_INCREF(__pyx_t_1);
  if (unlikely(__pyx_t_1 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 2101, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_num_asteroids = __pyx_t_1;
  __pyx_t_1 = 0;

+2102:         if num_asteroids == 0:

  __pyx_t_8 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_num_asteroids, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2102, __pyx_L1_error)
  if (__pyx_t_8) {
/* … */
  }

+2103:             return 0.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
    goto __pyx_L0;

 2104:         else:

+2105:             return total_speed/num_asteroids

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_total_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2105, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_v_num_asteroids); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2105, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_r = __pyx_t_6;
    __pyx_t_6 = 0;
    goto __pyx_L0;
  }

 2106: 

 2107:     # average_density = asteroid_density()

 2108:     # current_asteroids, total_asteroids = asteroid_counter(asteroids)

 2109:     # average_vel = average_velocity()

 2110:     # avg_speed = average_speed()

 2111:     # print(f"Average asteroid density: {average_density}, average vel: {average_vel}, average speed: {avg_speed}")

 2112: 

 2113: 

+2114: def asteroid_counter(asteroids: list[Asteroid]) -> tuple[int, int]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_75asteroid_counter(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_75asteroid_counter = {"asteroid_counter", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_75asteroid_counter, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_75asteroid_counter(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_asteroids = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("asteroid_counter (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroids,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2114, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2114, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "asteroid_counter", 0) < 0) __PYX_ERR(0, 2114, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("asteroid_counter", 1, 1, 1, i); __PYX_ERR(0, 2114, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2114, __pyx_L3_error)
    }
    __pyx_v_asteroids = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("asteroid_counter", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2114, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.asteroid_counter", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids), (&PyList_Type), 0, "asteroids", 2))) __PYX_ERR(0, 2114, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_74asteroid_counter(__pyx_self, __pyx_v_asteroids);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_74asteroid_counter(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_asteroids) {
  Py_ssize_t __pyx_v_current_count;
  PyObject *__pyx_v_total_count = 0;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.asteroid_counter", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_total_count);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2114, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2114, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_int_int) < 0) __PYX_ERR(0, 2114, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_75asteroid_counter, 0, __pyx_mstate_global->__pyx_n_u_asteroid_counter, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[107])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2114, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_asteroid_counter, __pyx_t_4) < 0) __PYX_ERR(0, 2114, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2115:     current_count = len(asteroids)

  __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_asteroids); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2115, __pyx_L1_error)
  __pyx_v_current_count = __pyx_t_1;

+2116:     total_count: int = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_total_count = __pyx_mstate_global->__pyx_int_0;

+2117:     for a in asteroids:

  __pyx_t_2 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_1 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2117, __pyx_L1_error)
      #endif
      if (__pyx_t_1 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_1);
    ++__pyx_t_1;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2117, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2118:         total_count += ASTEROID_COUNT_LOOKUP[a.size]

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROID_COUNT_LOOKUP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2118, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2118, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2118, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_total_count, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2118, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (!(likely(PyLong_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_4))) __PYX_ERR(0, 2118, __pyx_L1_error)
    __Pyx_DECREF_SET(__pyx_v_total_count, ((PyObject*)__pyx_t_4));
    __pyx_t_4 = 0;

+2119:     return total_count, current_count

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyLong_FromSsize_t(__pyx_v_current_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_v_total_count);
  __Pyx_GIVEREF(__pyx_v_total_count);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_total_count) != (0)) __PYX_ERR(0, 2119, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 2119, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_r = ((PyObject*)__pyx_t_4);
  __pyx_t_4 = 0;
  goto __pyx_L0;

 2120: 

 2121: 

+2122: class GameStatePlotter:

  __pyx_t_4 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_n_u_GameStatePlotter, __pyx_mstate_global->__pyx_n_u_GameStatePlotter, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
/* … */
  __pyx_t_9 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_mstate_global->__pyx_n_u_GameStatePlotter, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_GameStatePlotter, __pyx_t_9) < 0) __PYX_ERR(0, 2122, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2123:     # Use matplotlib to plot out the gamestate to view debug traces and stuff

+2124:     def __init__(self, game_state: GameState) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_16GameStatePlotter_1__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_16GameStatePlotter_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_16GameStatePlotter_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_16GameStatePlotter_1__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2124, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2124, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2124, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 2124, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, i); __PYX_ERR(0, 2124, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2124, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2124, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2124, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.GameStatePlotter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2124, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_16GameStatePlotter___init__(__pyx_self, __pyx_v_self, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_16GameStatePlotter___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.GameStatePlotter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2124, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2124, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_16GameStatePlotter_1__init__, 0, __pyx_mstate_global->__pyx_n_u_GameStatePlotter___init, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[108])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_9) < 0) __PYX_ERR(0, 2124, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+2125:         self.fig, self.ax = plt.subplots()

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2125, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_subplots); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2125, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2125, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 2125, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_2);
    } else {
      __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2125, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2125, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_2);
    }
    #else
    __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2125, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2125, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2125, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3);
    index = 0; __pyx_t_4 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    index = 1; __pyx_t_2 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_3), 2) < 0) __PYX_ERR(0, 2125, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 2125, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fig, __pyx_t_4) < 0) __PYX_ERR(0, 2125, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax, __pyx_t_2) < 0) __PYX_ERR(0, 2125, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2126:         self.ax.set_xlim([0, game_state.map_size[0]])

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2126, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 2126, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_xlim, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2126, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2127:         self.ax.set_ylim([0, game_state.map_size[1]])

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2127, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 2127, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_2};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_ylim, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2127, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2128:         self.ax.set_aspect('equal', adjustable='box')

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_t_2;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_mstate_global->__pyx_n_u_equal};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2128, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_adjustable, __pyx_mstate_global->__pyx_n_u_box, __pyx_t_4, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2128, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_set_aspect, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2128, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2129:         self.game_state = game_state

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state, ((PyObject *)__pyx_v_game_state)) < 0) __PYX_ERR(0, 2129, __pyx_L1_error)

 2130: 

+2131:     def fuse_time_to_color(self, remaining_time: float) -> str:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_16GameStatePlotter_3fuse_time_to_color(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_16GameStatePlotter_3fuse_time_to_color = {"fuse_time_to_color", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_16GameStatePlotter_3fuse_time_to_color, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_16GameStatePlotter_3fuse_time_to_color(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  double __pyx_v_remaining_time;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("fuse_time_to_color (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_remaining_time,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2131, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2131, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2131, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "fuse_time_to_color", 0) < 0) __PYX_ERR(0, 2131, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("fuse_time_to_color", 1, 2, 2, i); __PYX_ERR(0, 2131, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2131, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2131, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_remaining_time = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_remaining_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2131, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("fuse_time_to_color", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2131, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.GameStatePlotter.fuse_time_to_color", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_16GameStatePlotter_2fuse_time_to_color(__pyx_self, __pyx_v_self, __pyx_v_remaining_time);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_16GameStatePlotter_2fuse_time_to_color(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, double __pyx_v_remaining_time) {
  double __pyx_v_green_to_yellow_ratio;
  PyObject *__pyx_v_red = NULL;
  PyObject *__pyx_v_green = NULL;
  double __pyx_v_yellow_to_red_ratio;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.GameStatePlotter.fuse_time_to_color", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_red);
  __Pyx_XDECREF(__pyx_v_green);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_remaining_time, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2131, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 2131, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_16GameStatePlotter_3fuse_time_to_color, 0, __pyx_mstate_global->__pyx_n_u_GameStatePlotter_fuse_time_to_co, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[109])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_fuse_time_to_color, __pyx_t_2) < 0) __PYX_ERR(0, 2131, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2132:         if remaining_time >= MINE_FUSE_TIME:

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_remaining_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2132, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2132, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_4) {
/* … */
  }

+2133:             return "#00FF00"  # Green

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_00FF00);
    __pyx_r = __pyx_mstate_global->__pyx_kp_u_00FF00;
    goto __pyx_L0;

+2134:         elif remaining_time <= 0.0:

  __pyx_t_4 = (__pyx_v_remaining_time <= 0.0);
  if (__pyx_t_4) {
/* … */
  }

+2135:             return "#FF0000"  # Red

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_FF0000);
    __pyx_r = __pyx_mstate_global->__pyx_kp_u_FF0000;
    goto __pyx_L0;

 2136:         else:

 2137:             # Linearly interpolate between green and red

 2138:             # From green to yellow

+2139:             if remaining_time > 1.5:

  /*else*/ {
    __pyx_t_4 = (__pyx_v_remaining_time > 1.5);
    if (__pyx_t_4) {
/* … */
      goto __pyx_L4;
    }

 2140:                 # Interpolate between green and yellow

+2141:                 green_to_yellow_ratio = (remaining_time - 1.5)/1.5

      __pyx_v_green_to_yellow_ratio = ((__pyx_v_remaining_time - 1.5) / 1.5);

+2142:                 red = int(255*(1 - green_to_yellow_ratio))

      __pyx_t_3 = PyLong_FromDouble((255.0 * (1.0 - __pyx_v_green_to_yellow_ratio))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2142, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_v_red = ((PyObject*)__pyx_t_3);
      __pyx_t_3 = 0;

+2143:                 green = 255

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_255);
      __pyx_v_green = __pyx_mstate_global->__pyx_int_255;

 2144:             # From yellow to red

 2145:             else:

 2146:                 # Interpolate between yellow and red

+2147:                 yellow_to_red_ratio = remaining_time/1.5

    /*else*/ {
      __pyx_v_yellow_to_red_ratio = (__pyx_v_remaining_time / 1.5);

+2148:                 red = 255

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_255);
      __pyx_v_red = __pyx_mstate_global->__pyx_int_255;

+2149:                 green = int(255*yellow_to_red_ratio)

      __pyx_t_3 = PyLong_FromDouble((255.0 * __pyx_v_yellow_to_red_ratio)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2149, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_v_green = ((PyObject*)__pyx_t_3);
      __pyx_t_3 = 0;
    }
    __pyx_L4:;

 2150: 

 2151:             # Convert to hex

+2152:             return f"#{red:02x}{green:02x}00"

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __Pyx_PyObject_Format(__pyx_v_red, __pyx_mstate_global->__pyx_kp_u_02x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2152, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyObject_Format(__pyx_v_green, __pyx_mstate_global->__pyx_kp_u_02x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2152, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5[0] = __pyx_mstate_global->__pyx_kp_u__13;
    __pyx_t_5[1] = __pyx_t_3;
    __pyx_t_5[2] = __pyx_t_2;
    __pyx_t_5[3] = __pyx_mstate_global->__pyx_kp_u_00;
    __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_5, 4, 1 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 2, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2));
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2152, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_r = ((PyObject*)__pyx_t_1);
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

 2153: 

+2154:     def update_plot(self, asteroids: Optional[list[Asteroid]] = None, ship_state: Optional[Ship] = None, bullets: Optional[list[Bullet]] = None, special_bullets: Optional[list[Bullet]] = None, circled_asteroids: Optional[list[Asteroid]] = None, ghost_asteroids: Optional[list[Asteroid]] = None, forecasted_asteroids: Optional[list[Asteroid]] = None, mines: Optional[list[Mine]] = None, clear_plot: bool = True, pause_time: float = EPS, plot_title: str = '') -> None:

static PyObject *__pyx_pf_14neo_controller_155__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyTuple_New(11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 3, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 4, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 5, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 6, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 7, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_True));
  __Pyx_GIVEREF(((PyObject*)Py_True));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 8, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 9, __pyx_t_1) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_kp_u__3));
  __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_kp_u__3));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 10, ((PyObject*)__pyx_mstate_global->__pyx_kp_u__3)) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, Py_None) != (0)) __PYX_ERR(0, 2154, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_16GameStatePlotter_5update_plot(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_16GameStatePlotter_5update_plot = {"update_plot", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_16GameStatePlotter_5update_plot, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_16GameStatePlotter_5update_plot(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_asteroids = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  PyObject *__pyx_v_bullets = 0;
  PyObject *__pyx_v_special_bullets = 0;
  PyObject *__pyx_v_circled_asteroids = 0;
  PyObject *__pyx_v_ghost_asteroids = 0;
  PyObject *__pyx_v_forecasted_asteroids = 0;
  PyObject *__pyx_v_mines = 0;
  PyObject *__pyx_v_clear_plot = 0;
  double __pyx_v_pause_time;
  PyObject *__pyx_v_plot_title = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("update_plot (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_asteroids,&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_bullets,&__pyx_mstate_global->__pyx_n_u_special_bullets,&__pyx_mstate_global->__pyx_n_u_circled_asteroids,&__pyx_mstate_global->__pyx_n_u_ghost_asteroids,&__pyx_mstate_global->__pyx_n_u_forecasted_asteroids,&__pyx_mstate_global->__pyx_n_u_mines,&__pyx_mstate_global->__pyx_n_u_clear_plot,&__pyx_mstate_global->__pyx_n_u_pause_time,&__pyx_mstate_global->__pyx_n_u_plot_title,0};
  PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0};
    struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self);
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2154, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case 12:
        values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 11:
        values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "update_plot", 0) < 0) __PYX_ERR(0, 2154, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_14neo_controller_Ship *)Py_None));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[7]) values[7] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[8]) values[8] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[9]) values[9] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True)));
      if (!values[11]) values[11] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_kp_u__3)));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("update_plot", 0, 1, 12, i); __PYX_ERR(0, 2154, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case 12:
        values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 11:
        values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2154, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2154, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_14neo_controller_Ship *)Py_None));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[7]) values[7] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[8]) values[8] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[9]) values[9] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True)));
      if (!values[11]) values[11] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_kp_u__3)));
    }
    __pyx_v_self = values[0];
    __pyx_v_asteroids = ((PyObject*)values[1]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[2]);
    __pyx_v_bullets = ((PyObject*)values[3]);
    __pyx_v_special_bullets = ((PyObject*)values[4]);
    __pyx_v_circled_asteroids = ((PyObject*)values[5]);
    __pyx_v_ghost_asteroids = ((PyObject*)values[6]);
    __pyx_v_forecasted_asteroids = ((PyObject*)values[7]);
    __pyx_v_mines = ((PyObject*)values[8]);
    __pyx_v_clear_plot = values[9];
    if (values[10]) {
      __pyx_v_pause_time = __Pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_pause_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2154, __pyx_L3_error)
    } else {
      __pyx_v_pause_time = __pyx_dynamic_args->arg0;
    }
    __pyx_v_plot_title = ((PyObject*)values[11]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("update_plot", 0, 1, 12, __pyx_nargs); __PYX_ERR(0, 2154, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.GameStatePlotter.update_plot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids), (&PyList_Type), 1, "asteroids", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 1, "ship_state", 0))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bullets), (&PyList_Type), 1, "bullets", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_special_bullets), (&PyList_Type), 1, "special_bullets", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_circled_asteroids), (&PyList_Type), 1, "circled_asteroids", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ghost_asteroids), (&PyList_Type), 1, "ghost_asteroids", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_forecasted_asteroids), (&PyList_Type), 1, "forecasted_asteroids", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mines), (&PyList_Type), 1, "mines", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_plot_title), (&PyUnicode_Type), 0, "plot_title", 2))) __PYX_ERR(0, 2154, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_16GameStatePlotter_4update_plot(__pyx_self, __pyx_v_self, __pyx_v_asteroids, __pyx_v_ship_state, __pyx_v_bullets, __pyx_v_special_bullets, __pyx_v_circled_asteroids, __pyx_v_ghost_asteroids, __pyx_v_forecasted_asteroids, __pyx_v_mines, __pyx_v_clear_plot, __pyx_v_pause_time, __pyx_v_plot_title);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_16GameStatePlotter_4update_plot(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_asteroids, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state, PyObject *__pyx_v_bullets, PyObject *__pyx_v_special_bullets, PyObject *__pyx_v_circled_asteroids, PyObject *__pyx_v_ghost_asteroids, PyObject *__pyx_v_forecasted_asteroids, PyObject *__pyx_v_mines, PyObject *__pyx_v_clear_plot, double __pyx_v_pause_time, PyObject *__pyx_v_plot_title) {
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_asteroid_circle = NULL;
  PyObject *__pyx_v_highlight_circle = NULL;
  PyObject *__pyx_v_m = NULL;
  int __pyx_v_circle_hardcoded_coordinate;
  PyObject *__pyx_v_ship_size_base = NULL;
  PyObject *__pyx_v_ship_size_tip = NULL;
  double __pyx_v_ship_heading;
  PyObject *__pyx_v_ship_position = NULL;
  PyObject *__pyx_v_angle_rad = NULL;
  PyObject *__pyx_v_ship_vertices = NULL;
  PyObject *__pyx_v_ship = NULL;
  PyObject *__pyx_v_ship_circle = NULL;
  PyObject *__pyx_v_b = NULL;
  PyObject *__pyx_v_bullet_tail = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_INCREF(__pyx_v_asteroids);
  __Pyx_INCREF(__pyx_v_bullets);
  __Pyx_INCREF(__pyx_v_special_bullets);
  __Pyx_INCREF(__pyx_v_circled_asteroids);
  __Pyx_INCREF(__pyx_v_ghost_asteroids);
  __Pyx_INCREF(__pyx_v_forecasted_asteroids);
  __Pyx_INCREF(__pyx_v_mines);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("neo_controller.GameStatePlotter.update_plot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_asteroid_circle);
  __Pyx_XDECREF(__pyx_v_highlight_circle);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XDECREF(__pyx_v_ship_size_base);
  __Pyx_XDECREF(__pyx_v_ship_size_tip);
  __Pyx_XDECREF(__pyx_v_ship_position);
  __Pyx_XDECREF(__pyx_v_angle_rad);
  __Pyx_XDECREF(__pyx_v_ship_vertices);
  __Pyx_XDECREF(__pyx_v_ship);
  __Pyx_XDECREF(__pyx_v_ship_circle);
  __Pyx_XDECREF(__pyx_v_b);
  __Pyx_XDECREF(__pyx_v_bullet_tail);
  __Pyx_XDECREF(__pyx_v_asteroids);
  __Pyx_XDECREF(__pyx_v_bullets);
  __Pyx_XDECREF(__pyx_v_special_bullets);
  __Pyx_XDECREF(__pyx_v_circled_asteroids);
  __Pyx_XDECREF(__pyx_v_ghost_asteroids);
  __Pyx_XDECREF(__pyx_v_forecasted_asteroids);
  __Pyx_XDECREF(__pyx_v_mines);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_mstate_global->__pyx_kp_u_Optional_list_Asteroid) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_kp_u_Optional_Ship) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_mstate_global->__pyx_kp_u_Optional_list_Bullet) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_special_bullets, __pyx_mstate_global->__pyx_kp_u_Optional_list_Bullet) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_circled_asteroids, __pyx_mstate_global->__pyx_kp_u_Optional_list_Asteroid) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ghost_asteroids, __pyx_mstate_global->__pyx_kp_u_Optional_list_Asteroid) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_forecasted_asteroids, __pyx_mstate_global->__pyx_kp_u_Optional_list_Asteroid) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mines, __pyx_mstate_global->__pyx_kp_u_Optional_list_Mine) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_clear_plot, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pause_time, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_plot_title, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_16GameStatePlotter_5update_plot, 0, __pyx_mstate_global->__pyx_n_u_GameStatePlotter_update_plot, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[110])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_defaults)) __PYX_ERR(0, 2154, __pyx_L1_error)
  __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_v_14neo_controller_EPS;
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_14neo_controller_155__defaults__);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_update_plot, __pyx_t_9) < 0) __PYX_ERR(0, 2154, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
struct __pyx_defaults {
  PyObject_HEAD
  double arg0;
};

+2155:         if asteroids is None:

  __pyx_t_1 = (__pyx_v_asteroids == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+2156:             asteroids = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2156, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_asteroids, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+2157:         if bullets is None:

  __pyx_t_1 = (__pyx_v_bullets == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+2158:             bullets = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2158, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_bullets, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+2159:         if special_bullets is None:

  __pyx_t_1 = (__pyx_v_special_bullets == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+2160:             special_bullets = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_special_bullets, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+2161:         if circled_asteroids is None:

  __pyx_t_1 = (__pyx_v_circled_asteroids == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+2162:             circled_asteroids = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_circled_asteroids, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+2163:         if ghost_asteroids is None:

  __pyx_t_1 = (__pyx_v_ghost_asteroids == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+2164:             ghost_asteroids = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2164, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_ghost_asteroids, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+2165:         if forecasted_asteroids is None:

  __pyx_t_1 = (__pyx_v_forecasted_asteroids == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+2166:             forecasted_asteroids = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2166, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_forecasted_asteroids, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+2167:         if mines is None:

  __pyx_t_1 = (__pyx_v_mines == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+2168:             mines = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_mines, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+2169:         if clear_plot:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_clear_plot); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2169, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+2170:             self.ax.clear()

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2170, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2170, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2171:         self.ax.set_facecolor('black')

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2171, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_n_u_black};
    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_facecolor, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2171, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2172:         self.ax.set_xlim([0, self.game_state.map_size[0]])

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyList_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2172, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2172, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_7};
    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_xlim, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2172, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2173:         self.ax.set_ylim([0, self.game_state.map_size[1]])

  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_4 = __pyx_t_7;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2173, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2173, __pyx_L1_error);
  __pyx_t_3 = 0;
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6};
    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_ylim, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2174:         self.ax.set_aspect('equal', adjustable='box')

  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2174, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __pyx_t_6;
  __Pyx_INCREF(__pyx_t_7);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_mstate_global->__pyx_n_u_equal};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2174, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_adjustable, __pyx_mstate_global->__pyx_n_u_box, __pyx_t_4, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2174, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_set_aspect, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2174, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2175: 

+2176:         self.ax.set_title(plot_title, fontsize=14, color='black')

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2176, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_6, __pyx_v_plot_title};
    __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2176, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fontsize, __pyx_mstate_global->__pyx_int_14, __pyx_t_7, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2176, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_black, __pyx_t_7, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 2176, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_set_title, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2176, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2177: 

 2178:         # Draw asteroids and their velocities

+2179:         for a in asteroids:

  if (unlikely(__pyx_v_asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2179, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_8 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2179, __pyx_L1_error)
      #endif
      if (__pyx_t_8 >= __pyx_temp) break;
    }
    __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_8);
    ++__pyx_t_8;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2179, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2180:             if a:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_a); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2180, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2181:                 asteroid_circle = patches.Circle(a.position, a.radius, color='gray', fill=True)

      __pyx_t_7 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2181, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Circle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2181, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2181, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2181, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_7);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_7, __pyx_t_6, __pyx_t_9};
        __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2181, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_gray, __pyx_t_10, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 2181, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fill, Py_True, __pyx_t_10, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 2181, __pyx_L1_error)
        __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2181, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_asteroid_circle, __pyx_t_4);
      __pyx_t_4 = 0;

+2182:                 self.ax.add_patch(asteroid_circle)

      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2182, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_3 = __pyx_t_10;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_asteroid_circle};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2182, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2183:                 self.ax.arrow(a.position[0], a.position[1], a.velocity[0]*DELTA_TIME, a.velocity[1]*DELTA_TIME, head_width=3, head_length=5, fc='white', ec='white')

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_10 = __pyx_t_3;
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_12 = PyNumber_Multiply(__pyx_t_11, __pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_13 = PyNumber_Multiply(__pyx_t_11, __pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2183, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[5 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_10, __pyx_t_6, __pyx_t_7, __pyx_t_12, __pyx_t_13};
        __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2183, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_head_width, __pyx_mstate_global->__pyx_int_3, __pyx_t_9, __pyx_callargs+5, 0) < 0) __PYX_ERR(0, 2183, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_head_length, __pyx_mstate_global->__pyx_int_5, __pyx_t_9, __pyx_callargs+5, 1) < 0) __PYX_ERR(0, 2183, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fc, __pyx_mstate_global->__pyx_n_u_white, __pyx_t_9, __pyx_callargs+5, 2) < 0) __PYX_ERR(0, 2183, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ec, __pyx_mstate_global->__pyx_n_u_white, __pyx_t_9, __pyx_callargs+5, 3) < 0) __PYX_ERR(0, 2183, __pyx_L1_error)
        __pyx_t_4 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_arrow, __pyx_callargs+__pyx_t_5, (5-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2183, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2184:         for a in ghost_asteroids:

  if (unlikely(__pyx_v_ghost_asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2184, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_v_ghost_asteroids; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_8 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2184, __pyx_L1_error)
      #endif
      if (__pyx_t_8 >= __pyx_temp) break;
    }
    __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_8);
    ++__pyx_t_8;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2184, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2185:             if a:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_a); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2185, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2186:                 asteroid_circle = patches.Circle(a.position, a.radius, color='#333333', fill=True, zorder=-100)

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2186, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_Circle); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2186, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2186, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2186, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_13))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_13);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_3, __pyx_t_9, __pyx_t_12};
        __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2186, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_kp_u_333333, __pyx_t_7, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 2186, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fill, Py_True, __pyx_t_7, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 2186, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_zorder, __pyx_mstate_global->__pyx_int_neg_100, __pyx_t_7, __pyx_callargs+3, 2) < 0) __PYX_ERR(0, 2186, __pyx_L1_error)
        __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_13, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2186, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_asteroid_circle, __pyx_t_4);
      __pyx_t_4 = 0;

+2187:                 self.ax.add_patch(asteroid_circle)

      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2187, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_13 = __pyx_t_7;
      __Pyx_INCREF(__pyx_t_13);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_v_asteroid_circle};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2187, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2188:                 # self.ax.arrow(a.position[0], a.position[1], a.velocity[0]*delta_time, a.velocity[1]*delta_time, head_width=3, head_length=5, fc='white', ec='white')

+2189:         for a in forecasted_asteroids:

  if (unlikely(__pyx_v_forecasted_asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2189, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_v_forecasted_asteroids; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_8 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2189, __pyx_L1_error)
      #endif
      if (__pyx_t_8 >= __pyx_temp) break;
    }
    __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_8);
    ++__pyx_t_8;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2190:             if a:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_a); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2190, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2191:                 asteroid_circle = patches.Circle(a.position, a.radius, color='#440000', fill=True, zorder=100, alpha=0.4)

      __pyx_t_7 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_Circle); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_12))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12);
        assert(__pyx_t_7);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_7, __pyx_t_13, __pyx_t_9};
        __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2191, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_kp_u_440000, __pyx_t_3, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 2191, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fill, Py_True, __pyx_t_3, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 2191, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_zorder, __pyx_mstate_global->__pyx_int_100, __pyx_t_3, __pyx_callargs+3, 2) < 0) __PYX_ERR(0, 2191, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_alpha, __pyx_mstate_global->__pyx_float_0_4, __pyx_t_3, __pyx_callargs+3, 3) < 0) __PYX_ERR(0, 2191, __pyx_L1_error)
        __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_12, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3);
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2191, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_asteroid_circle, __pyx_t_4);
      __pyx_t_4 = 0;

+2192:                 self.ax.add_patch(asteroid_circle)

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2192, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_12 = __pyx_t_3;
      __Pyx_INCREF(__pyx_t_12);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_v_asteroid_circle};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2192, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2193:         for a in circled_asteroids:

  if (unlikely(__pyx_v_circled_asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2193, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_v_circled_asteroids; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_8 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2193, __pyx_L1_error)
      #endif
      if (__pyx_t_8 >= __pyx_temp) break;
    }
    __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_8);
    ++__pyx_t_8;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2193, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2194:             if a:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_a); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2194, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2195:                 highlight_circle = patches.Circle(a.position, a.radius + 5, color='orange', fill=False)

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_Circle); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_t_13, __pyx_mstate_global->__pyx_int_5, 5, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_t_12, __pyx_t_7};
        __pyx_t_13 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2195, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_orange, __pyx_t_13, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 2195, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fill, Py_False, __pyx_t_13, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 2195, __pyx_L1_error)
        __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_9, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_13);
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2195, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_highlight_circle, __pyx_t_4);
      __pyx_t_4 = 0;

+2196:                 self.ax.add_patch(highlight_circle)

      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2196, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_9 = __pyx_t_13;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_highlight_circle};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2196, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2197: 

+2198:         for m in mines:

  if (unlikely(__pyx_v_mines == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2198, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_v_mines; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_8 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2198, __pyx_L1_error)
      #endif
      if (__pyx_t_8 >= __pyx_temp) break;
    }
    __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_8);
    ++__pyx_t_8;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2198, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2199:             if m:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_m); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2199, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2200:                 highlight_circle = patches.Circle(m.position, MINE_BLAST_RADIUS, color=self.fuse_time_to_color(m.remaining_time), fill=False)

      __pyx_t_13 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2200, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_Circle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2200, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2200, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2200, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_6 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_6);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2200, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_10};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_fuse_time_to_color, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2200, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_13);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_13);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_13, __pyx_t_9, __pyx_t_12};
        __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2200, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_t_3, __pyx_t_10, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 2200, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fill, Py_False, __pyx_t_10, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 2200, __pyx_L1_error)
        __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_7, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2200, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_highlight_circle, __pyx_t_4);
      __pyx_t_4 = 0;

+2201:                 self.ax.add_patch(highlight_circle)

      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2201, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_7 = __pyx_t_10;
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_highlight_circle};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2201, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2202: 

 2203:         # Hard code a circle so I can see what a coordinate on screen is for debugging

+2204:         circle_hardcoded_coordinate = False

  __pyx_v_circle_hardcoded_coordinate = 0;

+2205:         if circle_hardcoded_coordinate:

  if (__pyx_v_circle_hardcoded_coordinate) {
/* … */
  }

+2206:             highlight_circle = patches.Circle((1017.3500530032204, 423.2001881178426), 25, color='red', fill=False)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2206, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Circle); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2206, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[14] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_float_1017_3500530032204, __pyx_mstate_global->__pyx_float_423_2001881178426); if (unlikely(!__pyx_mstate_global->__pyx_tuple[14])) __PYX_ERR(0, 2206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[14]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[14]);
    __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2206, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_red) < 0) __PYX_ERR(0, 2206, __pyx_L1_error)
    if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fill, Py_False) < 0) __PYX_ERR(0, 2206, __pyx_L1_error)
    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[15], __pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2206, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF_SET(__pyx_v_highlight_circle, __pyx_t_10);
    __pyx_t_10 = 0;
  __pyx_mstate_global->__pyx_tuple[15] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_tuple[14], __pyx_mstate_global->__pyx_int_25); if (unlikely(!__pyx_mstate_global->__pyx_tuple[15])) __PYX_ERR(0, 2206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[15]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[15]);

+2207:             self.ax.add_patch(highlight_circle)

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __pyx_t_4;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_highlight_circle};
      __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2207, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
    }
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 2208: 

+2209:         if ship_state:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_ship_state)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2209, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

 2210:             # Draw the ship as an elongated triangle

+2211:             ship_size_base = SHIP_RADIUS

    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_v_ship_size_base = __pyx_t_10;
    __pyx_t_10 = 0;

+2212:             ship_size_tip = SHIP_RADIUS

    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_v_ship_size_tip = __pyx_t_10;
    __pyx_t_10 = 0;

+2213:             ship_heading = ship_state.heading

    __pyx_t_14 = __pyx_v_ship_state->heading;
    __pyx_v_ship_heading = __pyx_t_14;

+2214:             ship_position = ship_state.position

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2214, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_v_ship_position = __pyx_t_10;
    __pyx_t_10 = 0;

+2215:             angle_rad = radians(ship_heading)

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2215, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_ship_heading); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2215, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
      __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2215, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
    }
    __pyx_v_angle_rad = __pyx_t_10;
    __pyx_t_10 = 0;

+2216:             ship_vertices = [

    __pyx_t_12 = PyList_New(3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2216, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_GIVEREF(__pyx_t_4);
    if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2216, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_10);
    if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 2216, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 2216, __pyx_L1_error);
    __pyx_t_4 = 0;
    __pyx_t_10 = 0;
    __pyx_t_3 = 0;
    __pyx_v_ship_vertices = ((PyObject*)__pyx_t_12);
    __pyx_t_12 = 0;

+2217:                 (ship_position[0] + ship_size_tip*cos(angle_rad), ship_position[1] + ship_size_tip*sin(angle_rad)),

    __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_ship_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_v_angle_rad); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2217, __pyx_L1_error)
    __pyx_t_2 = PyFloat_FromDouble(cos(__pyx_t_14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = PyNumber_Multiply(__pyx_v_ship_size_tip, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Add(__pyx_t_10, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_ship_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_v_angle_rad); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2217, __pyx_L1_error)
    __pyx_t_10 = PyFloat_FromDouble(sin(__pyx_t_14)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_4 = PyNumber_Multiply(__pyx_v_ship_size_tip, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyNumber_Add(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_2);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2217, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_10);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 2217, __pyx_L1_error);
    __pyx_t_2 = 0;
    __pyx_t_10 = 0;

+2218:                 (ship_position[0] + ship_size_base*cos(angle_rad + pi*3/4), ship_position[1] + ship_size_base*sin(angle_rad + pi*3/4)),

    __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_ship_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_2 = PyFloat_FromDouble(((M_PI * 3.0) / 4.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = PyNumber_Add(__pyx_v_angle_rad, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyFloat_FromDouble(cos(__pyx_t_14)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_ship_size_base, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_Add(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ship_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_10 = PyFloat_FromDouble(((M_PI * 3.0) / 4.0)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_3 = PyNumber_Add(__pyx_v_angle_rad, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyFloat_FromDouble(sin(__pyx_t_14)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_10 = PyNumber_Multiply(__pyx_v_ship_size_base, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_GIVEREF(__pyx_t_7);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 2218, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2218, __pyx_L1_error);
    __pyx_t_7 = 0;
    __pyx_t_3 = 0;

+2219:                 (ship_position[0] + ship_size_base*cos(angle_rad - pi*3/4), ship_position[1] + ship_size_base*sin(angle_rad - pi*3/4)),

    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_ship_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = PyFloat_FromDouble(((M_PI * 3.0) / 4.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_2 = PyNumber_Subtract(__pyx_v_angle_rad, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyFloat_FromDouble(cos(__pyx_t_14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = PyNumber_Multiply(__pyx_v_ship_size_base, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_ship_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = PyFloat_FromDouble(((M_PI * 3.0) / 4.0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_12 = PyNumber_Subtract(__pyx_v_angle_rad, __pyx_t_3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_12); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = PyFloat_FromDouble(sin(__pyx_t_14)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_3 = PyNumber_Multiply(__pyx_v_ship_size_base, __pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = PyNumber_Add(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_2);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2219, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_12);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 2219, __pyx_L1_error);
    __pyx_t_2 = 0;
    __pyx_t_12 = 0;

 2220:             ]

+2221:             ship = patches.Polygon(ship_vertices, color='green', fill=True)

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2221, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_Polygon); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2221, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_ship_vertices};
      __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2221, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_green, __pyx_t_10, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2221, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fill, Py_True, __pyx_t_10, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 2221, __pyx_L1_error)
      __pyx_t_12 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2221, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __pyx_v_ship = __pyx_t_12;
    __pyx_t_12 = 0;

+2222:             self.ax.add_patch(ship)

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2222, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_4 = __pyx_t_10;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_ship};
      __pyx_t_12 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2222, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;

 2223: 

 2224:             # Draw the ship's hitbox as a blue circle

+2225:             ship_circle = patches.Circle(ship_position, SHIP_RADIUS, color='blue', fill=False)

    __pyx_t_10 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_patches); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2225, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Circle); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2225, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2225, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_10);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_10, __pyx_v_ship_position, __pyx_t_4};
      __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2225, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_blue, __pyx_t_2, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 2225, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fill, Py_False, __pyx_t_2, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 2225, __pyx_L1_error)
      __pyx_t_12 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2);
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2225, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __pyx_v_ship_circle = __pyx_t_12;
    __pyx_t_12 = 0;

+2226:             self.ax.add_patch(ship_circle)

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2226, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __pyx_t_2;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_ship_circle};
      __pyx_t_12 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_patch, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2226, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;

 2227: 

 2228:         # Draw arrow line segments for bullets

+2229:         for b in bullets:

  if (unlikely(__pyx_v_bullets == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2229, __pyx_L1_error)
  }
  __pyx_t_12 = __pyx_v_bullets; __Pyx_INCREF(__pyx_t_12);
  __pyx_t_8 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_12);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2229, __pyx_L1_error)
      #endif
      if (__pyx_t_8 >= __pyx_temp) break;
    }
    __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_12, __pyx_t_8);
    ++__pyx_t_8;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2229, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;

+2230:             if b:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_b); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2230, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2231:                 bullet_tail = (b.position[0] - BULLET_LENGTH*cos(radians(b.heading)), b.position[1] - BULLET_LENGTH*sin(radians(b.heading)))

      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_10 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_10);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_10);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2231, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyFloat_FromDouble(cos(__pyx_t_14)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_7 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_9 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_10))) {
        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10);
        assert(__pyx_t_9);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
        __Pyx_INCREF(__pyx_t_9);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_13};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2231, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = PyFloat_FromDouble(sin(__pyx_t_14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_10 = PyNumber_Multiply(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = PyNumber_Subtract(__pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2231, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2231, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_2);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 2231, __pyx_L1_error);
      __pyx_t_4 = 0;
      __pyx_t_2 = 0;
      __Pyx_XDECREF_SET(__pyx_v_bullet_tail, ((PyObject*)__pyx_t_10));
      __pyx_t_10 = 0;

+2232:                 self.ax.arrow(bullet_tail[0], bullet_tail[1], b.position[0] - bullet_tail[0], b.position[1] - bullet_tail[1], head_width=3, head_length=5, fc='red', ec='red')

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __pyx_t_4;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyNumber_Subtract(__pyx_t_7, __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = PyNumber_Subtract(__pyx_t_13, __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 1)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[5 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_2, __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 0), __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 1), __pyx_t_3, __pyx_t_7};
        __pyx_t_13 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2232, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_head_width, __pyx_mstate_global->__pyx_int_3, __pyx_t_13, __pyx_callargs+5, 0) < 0) __PYX_ERR(0, 2232, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_head_length, __pyx_mstate_global->__pyx_int_5, __pyx_t_13, __pyx_callargs+5, 1) < 0) __PYX_ERR(0, 2232, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fc, __pyx_mstate_global->__pyx_n_u_red, __pyx_t_13, __pyx_callargs+5, 2) < 0) __PYX_ERR(0, 2232, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ec, __pyx_mstate_global->__pyx_n_u_red, __pyx_t_13, __pyx_callargs+5, 3) < 0) __PYX_ERR(0, 2232, __pyx_L1_error)
        __pyx_t_10 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_arrow, __pyx_callargs+__pyx_t_5, (5-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_13);
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2232, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+2233:         for b in special_bullets:

  if (unlikely(__pyx_v_special_bullets == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2233, __pyx_L1_error)
  }
  __pyx_t_12 = __pyx_v_special_bullets; __Pyx_INCREF(__pyx_t_12);
  __pyx_t_8 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_12);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2233, __pyx_L1_error)
      #endif
      if (__pyx_t_8 >= __pyx_temp) break;
    }
    __pyx_t_10 = __Pyx_PyList_GetItemRef(__pyx_t_12, __pyx_t_8);
    ++__pyx_t_8;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2233, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_10);
    __pyx_t_10 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;

+2234:             if b:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_b); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2234, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2235:                 bullet_tail = (b.position[0] - BULLET_LENGTH*cos(radians(b.heading)), b.position[1] - BULLET_LENGTH*sin(radians(b.heading)))

      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_7 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_7);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_2};
        __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2235, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
      }
      __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_13); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = PyFloat_FromDouble(cos(__pyx_t_14)); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_3 = PyNumber_Multiply(__pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = PyNumber_Subtract(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_2 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_2);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_9};
        __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2235, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_t_10); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = PyFloat_FromDouble(sin(__pyx_t_14)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = PyNumber_Subtract(__pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_GIVEREF(__pyx_t_13);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13) != (0)) __PYX_ERR(0, 2235, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_10);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 2235, __pyx_L1_error);
      __pyx_t_13 = 0;
      __pyx_t_10 = 0;
      __Pyx_XDECREF_SET(__pyx_v_bullet_tail, ((PyObject*)__pyx_t_7));
      __pyx_t_7 = 0;

+2236:                 self.ax.arrow(bullet_tail[0], bullet_tail[1], b.position[0] - bullet_tail[0], b.position[1] - bullet_tail[1], head_width=3, head_length=5, fc='green', ec='green')

      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ax); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2236, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_10 = __pyx_t_13;
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2236, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2236, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2236, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2236, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2236, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyNumber_Subtract(__pyx_t_9, __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2236, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[5 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_10, __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 0), __Pyx_PyTuple_GET_ITEM(__pyx_v_bullet_tail, 1), __pyx_t_4, __pyx_t_3};
        __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_head_width, __pyx_mstate_global->__pyx_int_3, __pyx_t_9, __pyx_callargs+5, 0) < 0) __PYX_ERR(0, 2236, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_head_length, __pyx_mstate_global->__pyx_int_5, __pyx_t_9, __pyx_callargs+5, 1) < 0) __PYX_ERR(0, 2236, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fc, __pyx_mstate_global->__pyx_n_u_green, __pyx_t_9, __pyx_callargs+5, 2) < 0) __PYX_ERR(0, 2236, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ec, __pyx_mstate_global->__pyx_n_u_green, __pyx_t_9, __pyx_callargs+5, 3) < 0) __PYX_ERR(0, 2236, __pyx_L1_error)
        __pyx_t_7 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_arrow, __pyx_callargs+__pyx_t_5, (5-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+2237:         plt.draw()

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_draw); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
    __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2237, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
  }
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;

+2238:         plt.pause(pause_time)

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_pause); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_pause_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_13))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_13);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_7};
    __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2238, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
  }
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;

 2239: 

 2240: 

+2241: def append_dict_to_file(dict_data: dict[Any, Any], file_path: str) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_77append_dict_to_file(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_76append_dict_to_file, "\n    This function takes a dictionary and appends it as a string in a JSON-like format to a text file.\n\n    :param dict_data: dictionary to be converted to a string and appended.\n    :param file_path: Path of the text file to append the data to.\n    ");
static PyMethodDef __pyx_mdef_14neo_controller_77append_dict_to_file = {"append_dict_to_file", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_77append_dict_to_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_76append_dict_to_file};
static PyObject *__pyx_pw_14neo_controller_77append_dict_to_file(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_dict_data = 0;
  PyObject *__pyx_v_file_path = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("append_dict_to_file (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_dict_data,&__pyx_mstate_global->__pyx_n_u_file_path,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2241, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2241, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2241, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "append_dict_to_file", 0) < 0) __PYX_ERR(0, 2241, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("append_dict_to_file", 1, 2, 2, i); __PYX_ERR(0, 2241, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2241, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2241, __pyx_L3_error)
    }
    __pyx_v_dict_data = ((PyObject*)values[0]);
    __pyx_v_file_path = ((PyObject*)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("append_dict_to_file", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2241, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.append_dict_to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dict_data), (&PyDict_Type), 0, "dict_data", 2))) __PYX_ERR(0, 2241, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_file_path), (&PyUnicode_Type), 0, "file_path", 2))) __PYX_ERR(0, 2241, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_76append_dict_to_file(__pyx_self, __pyx_v_dict_data, __pyx_v_file_path);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_76append_dict_to_file(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_dict_data, PyObject *__pyx_v_file_path) {
  PyObject *__pyx_v_json = NULL;
  PyObject *__pyx_v_dict_string = NULL;
  PyObject *__pyx_v_file = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.append_dict_to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_json);
  __Pyx_XDECREF(__pyx_v_dict_string);
  __Pyx_XDECREF(__pyx_v_file);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2241, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_dict_data, __pyx_mstate_global->__pyx_kp_u_dict_Any_Any) < 0) __PYX_ERR(0, 2241, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_file_path, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 2241, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2241, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_77append_dict_to_file, 0, __pyx_mstate_global->__pyx_n_u_append_dict_to_file, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[111])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2241, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_append_dict_to_file, __pyx_t_9) < 0) __PYX_ERR(0, 2241, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 2242:     """

 2243:     This function takes a dictionary and appends it as a string in a JSON-like format to a text file.

 2244: 

 2245:     :param dict_data: dictionary to be converted to a string and appended.

 2246:     :param file_path: Path of the text file to append the data to.

 2247:     """

+2248:     import json

  __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_json, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_json = __pyx_t_1;
  __pyx_t_1 = 0;

 2249: 

 2250:     # Convert the dictionary to a JSON-like string

+2251:     dict_string = json.dumps(dict_data, indent=4)

  __pyx_t_2 = __pyx_v_json;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_v_dict_data};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2251, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_indent, __pyx_mstate_global->__pyx_int_4, __pyx_t_4, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 2251, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_dumps, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2251, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_dict_string = __pyx_t_1;
  __pyx_t_1 = 0;

 2252: 

 2253:     # Append the string to the file

+2254:     with open(file_path, 'a') as file:

  /*with:*/ {
    __pyx_t_4 = NULL;
    __Pyx_INCREF(__pyx_builtin_open);
    __pyx_t_2 = __pyx_builtin_open; 
    __pyx_t_3 = 1;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_file_path, __pyx_mstate_global->__pyx_n_u_a};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2254, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2254, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = NULL;
    __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2254, __pyx_L3_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = 1;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_3 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2254, __pyx_L3_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_6 = __pyx_t_2;
    __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    /*try:*/ {
      {
        /*try:*/ {
          __pyx_v_file = __pyx_t_6;
          __pyx_t_6 = 0;
/* … */
        }
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        goto __pyx_L12_try_end;
        __pyx_L7_error:;
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        /*except:*/ {
          __Pyx_AddTraceback("neo_controller.append_dict_to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 2254, __pyx_L9_except_error)
          __Pyx_XGOTREF(__pyx_t_6);
          __Pyx_XGOTREF(__pyx_t_2);
          __Pyx_XGOTREF(__pyx_t_1);
          __pyx_t_4 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2254, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2254, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_10);
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (__pyx_t_11 < 0) __PYX_ERR(0, 2254, __pyx_L9_except_error)
          __pyx_t_12 = (!__pyx_t_11);
          if (unlikely(__pyx_t_12)) {
            __Pyx_GIVEREF(__pyx_t_6);
            __Pyx_GIVEREF(__pyx_t_2);
            __Pyx_XGIVEREF(__pyx_t_1);
            __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_2, __pyx_t_1);
            __pyx_t_6 = 0;  __pyx_t_2 = 0;  __pyx_t_1 = 0; 
            __PYX_ERR(0, 2254, __pyx_L9_except_error)
          }
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          goto __pyx_L8_exception_handled;
        }
        __pyx_L9_except_error:;
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
        goto __pyx_L1_error;
        __pyx_L8_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
        __pyx_L12_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_5) {
          __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[9], NULL);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2254, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        goto __pyx_L6;
      }
      __pyx_L6:;
    }
    goto __pyx_L16;
    __pyx_L3_error:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L1_error;
    __pyx_L16:;
  }

+2255:         file.write(dict_string + "\n")

          __pyx_t_1 = __pyx_v_file;
          __Pyx_INCREF(__pyx_t_1);
          __pyx_t_2 = PyNumber_Add(__pyx_v_dict_string, __pyx_mstate_global->__pyx_kp_u__12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2255, __pyx_L7_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_3 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_2};
            __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2255, __pyx_L7_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 2256: 

 2257: 

+2258: def get_other_ships(game_state: GameState, self_ship_id: int) -> list[Ship]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_79get_other_ships(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_79get_other_ships = {"get_other_ships", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_79get_other_ships, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_79get_other_ships(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  PyObject *__pyx_v_self_ship_id = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_other_ships (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_self_ship_id,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2258, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2258, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2258, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_other_ships", 0) < 0) __PYX_ERR(0, 2258, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_other_ships", 1, 2, 2, i); __PYX_ERR(0, 2258, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2258, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2258, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
    __pyx_v_self_ship_id = ((PyObject*)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_other_ships", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2258, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_other_ships", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2258, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_self_ship_id), (&PyLong_Type), 0, "self_ship_id", 2))) __PYX_ERR(0, 2258, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_78get_other_ships(__pyx_self, __pyx_v_game_state, __pyx_v_self_ship_id);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_78get_other_ships(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, PyObject *__pyx_v_self_ship_id) {
  PyObject *__pyx_9genexpr15__pyx_v_ship = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.get_other_ships", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_9genexpr15__pyx_v_ship);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2258, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2258, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_self_ship_id, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2258, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Ship) < 0) __PYX_ERR(0, 2258, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_79get_other_ships, 0, __pyx_mstate_global->__pyx_n_u_get_other_ships, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[112])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2258, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_other_ships, __pyx_t_4) < 0) __PYX_ERR(0, 2258, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2259:     return [ship for ship in game_state.ships if ship.id != self_ship_id]

  __Pyx_XDECREF(__pyx_r);
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2259, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (unlikely(__pyx_v_game_state->ships == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 2259, __pyx_L5_error)
    }
    __pyx_t_2 = __pyx_v_game_state->ships; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2259, __pyx_L5_error)
        #endif
        if (__pyx_t_3 >= __pyx_temp) break;
      }
      __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3);
      ++__pyx_t_3;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2259, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_9genexpr15__pyx_v_ship, __pyx_t_4);
      __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr15__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_id); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2259, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_v_self_ship_id, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2259, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2259, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_6) {
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_9genexpr15__pyx_v_ship))) __PYX_ERR(0, 2259, __pyx_L5_error)
      }
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_9genexpr15__pyx_v_ship); __pyx_9genexpr15__pyx_v_ship = 0;
    goto __pyx_L10_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_9genexpr15__pyx_v_ship); __pyx_9genexpr15__pyx_v_ship = 0;
    goto __pyx_L1_error;
    __pyx_L10_exit_scope:;
  } /* exit inner scope */
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 2260: 

 2261: 

+2262: def angle_difference_rad(angle1: float, angle2: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_81angle_difference_rad(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_81angle_difference_rad = {"angle_difference_rad", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_81angle_difference_rad, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_81angle_difference_rad(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_angle1;
  double __pyx_v_angle2;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("angle_difference_rad (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_angle1,&__pyx_mstate_global->__pyx_n_u_angle2,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2262, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2262, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2262, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "angle_difference_rad", 0) < 0) __PYX_ERR(0, 2262, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("angle_difference_rad", 1, 2, 2, i); __PYX_ERR(0, 2262, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2262, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2262, __pyx_L3_error)
    }
    __pyx_v_angle1 = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_angle1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2262, __pyx_L3_error)
    __pyx_v_angle2 = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_angle2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2262, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("angle_difference_rad", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2262, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.angle_difference_rad", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_80angle_difference_rad(__pyx_self, __pyx_v_angle1, __pyx_v_angle2);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_80angle_difference_rad(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_angle1, double __pyx_v_angle2) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.angle_difference_rad", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2262, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_angle1, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2262, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_angle2, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2262, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2262, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_81angle_difference_rad, 0, __pyx_mstate_global->__pyx_n_u_angle_difference_rad, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[113])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2262, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_angle_difference_rad, __pyx_t_9) < 0) __PYX_ERR(0, 2262, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 2263:     # Calculate the raw difference, and use modulo to wrap around the angle to between -pi to pi

+2264:     return (angle1 - angle2 + pi) % TAU - pi

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((__pyx_v_angle1 - __pyx_v_angle2) + M_PI);
  if (unlikely(__pyx_v_14neo_controller_TAU == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
    __PYX_ERR(0, 2264, __pyx_L1_error)
  }
  __pyx_t_2 = PyFloat_FromDouble((__Pyx_mod_double(__pyx_t_1, __pyx_v_14neo_controller_TAU, 0) - M_PI)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2264, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 2265: 

 2266: 

+2267: def angle_difference_deg(angle1: float, angle2: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_83angle_difference_deg(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_83angle_difference_deg = {"angle_difference_deg", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_83angle_difference_deg, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_83angle_difference_deg(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_angle1;
  double __pyx_v_angle2;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("angle_difference_deg (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_angle1,&__pyx_mstate_global->__pyx_n_u_angle2,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2267, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2267, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2267, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "angle_difference_deg", 0) < 0) __PYX_ERR(0, 2267, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("angle_difference_deg", 1, 2, 2, i); __PYX_ERR(0, 2267, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2267, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2267, __pyx_L3_error)
    }
    __pyx_v_angle1 = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_angle1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2267, __pyx_L3_error)
    __pyx_v_angle2 = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_angle2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2267, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("angle_difference_deg", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2267, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.angle_difference_deg", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_82angle_difference_deg(__pyx_self, __pyx_v_angle1, __pyx_v_angle2);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_82angle_difference_deg(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_angle1, double __pyx_v_angle2) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.angle_difference_deg", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2267, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_angle1, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2267, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_angle2, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2267, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2267, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_83angle_difference_deg, 0, __pyx_mstate_global->__pyx_n_u_angle_difference_deg, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[114])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2267, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_angle_difference_deg, __pyx_t_4) < 0) __PYX_ERR(0, 2267, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2268:     # Calculate the raw difference, and use modulo to wrap around the angle to between -180 to 180

+2269:     return (angle1 - angle2 + 180.0) % 360.0 - 180.0

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble((__Pyx_mod_double(((__pyx_v_angle1 - __pyx_v_angle2) + 180.0), 360.0, 1) - 180.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2269, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 2270: 

 2271: 

+2272: def get_ship_maneuver_move_sequence(ship_heading_angle: float, ship_cruise_speed: float, ship_accel_turn_rate: float, ship_cruise_timesteps: int, ship_cruise_turn_rate: float, ship_starting_speed: float = 0.0) -> list[Action]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_85get_ship_maneuver_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_85get_ship_maneuver_move_sequence = {"get_ship_maneuver_move_sequence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_85get_ship_maneuver_move_sequence, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_85get_ship_maneuver_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_ship_heading_angle;
  double __pyx_v_ship_cruise_speed;
  double __pyx_v_ship_accel_turn_rate;
  PyObject *__pyx_v_ship_cruise_timesteps = 0;
  double __pyx_v_ship_cruise_turn_rate;
  double __pyx_v_ship_starting_speed;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_ship_maneuver_move_sequence (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ship_heading_angle,&__pyx_mstate_global->__pyx_n_u_ship_cruise_speed,&__pyx_mstate_global->__pyx_n_u_ship_accel_turn_rate,&__pyx_mstate_global->__pyx_n_u_ship_cruise_timesteps,&__pyx_mstate_global->__pyx_n_u_ship_cruise_turn_rate,&__pyx_mstate_global->__pyx_n_u_ship_starting_speed,0};
  PyObject* values[6] = {0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2272, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2272, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2272, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2272, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2272, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2272, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2272, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_ship_maneuver_move_sequence", 0) < 0) __PYX_ERR(0, 2272, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 5; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_ship_maneuver_move_sequence", 0, 5, 6, i); __PYX_ERR(0, 2272, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2272, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2272, __pyx_L3_error)
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2272, __pyx_L3_error)
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2272, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2272, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2272, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_ship_heading_angle = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_ship_heading_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2272, __pyx_L3_error)
    __pyx_v_ship_cruise_speed = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_ship_cruise_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2272, __pyx_L3_error)
    __pyx_v_ship_accel_turn_rate = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ship_accel_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2272, __pyx_L3_error)
    __pyx_v_ship_cruise_timesteps = ((PyObject*)values[3]);
    __pyx_v_ship_cruise_turn_rate = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_ship_cruise_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2272, __pyx_L3_error)
    if (values[5]) {
      __pyx_v_ship_starting_speed = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_ship_starting_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2272, __pyx_L3_error)
    } else {
      __pyx_v_ship_starting_speed = ((double)((double)0.0));
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_ship_maneuver_move_sequence", 0, 5, 6, __pyx_nargs); __PYX_ERR(0, 2272, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_cruise_timesteps), (&PyLong_Type), 0, "ship_cruise_timesteps", 2))) __PYX_ERR(0, 2272, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_84get_ship_maneuver_move_sequence(__pyx_self, __pyx_v_ship_heading_angle, __pyx_v_ship_cruise_speed, __pyx_v_ship_accel_turn_rate, __pyx_v_ship_cruise_timesteps, __pyx_v_ship_cruise_turn_rate, __pyx_v_ship_starting_speed);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_84get_ship_maneuver_move_sequence(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_ship_heading_angle, double __pyx_v_ship_cruise_speed, double __pyx_v_ship_accel_turn_rate, PyObject *__pyx_v_ship_cruise_timesteps, double __pyx_v_ship_cruise_turn_rate, double __pyx_v_ship_starting_speed) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_cur_scope;
  PyObject *__pyx_v_rotate_heading = 0;
  PyObject *__pyx_v_accelerate = 0;
  PyObject *__pyx_v_cruise = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *)__pyx_tp_new_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 2272, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_rotate_heading);
  __Pyx_XDECREF(__pyx_v_accelerate);
  __Pyx_XDECREF(__pyx_v_cruise);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_9 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_heading_angle, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_cruise_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_accel_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_starting_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Action) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_85get_ship_maneuver_move_sequence, 0, __pyx_mstate_global->__pyx_n_u_get_ship_maneuver_move_sequence_5, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[115])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_ship_maneuver_move_sequence_5, __pyx_t_2) < 0) __PYX_ERR(0, 2272, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence {
  PyObject_HEAD
  PyObject *__pyx_v_move_sequence;
  PyObject *__pyx_v_ship_speed;
  PyObject *__pyx_v_update;
};

 2273:     # This is a silly code duplication to get a super optimized class for getting the ship's move sequence. Using the entire Simulation class is overkill and too much.

+2274:     move_sequence: list[Action] = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2274, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_move_sequence = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2275:     ship_speed = ship_starting_speed

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_ship_starting_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2275, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_ship_speed = __pyx_t_1;
  __pyx_t_1 = 0;

 2276:     # assert isclose(ship_starting_speed, 0.0), f"The ship maneuver should start with 0 speed! It's actually {ship_starting_speed}. Unless... we just were saved by the other ship, so we're starting a maneuver while in the middle of another maneuver! In which case, you can safely ignore this assertion."

 2277:     #if not is_close(ship_starting_speed, 0.0):

 2278:     #    print(f"The ship maneuver should start with 0 speed! It's actually {ship_starting_speed}. Unless... we just were saved by the other ship, so we're starting a maneuver while in the middle of another maneuver!")

+2279:     def rotate_heading(heading_difference_deg: float) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_1rotate_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_1rotate_heading = {"rotate_heading", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_1rotate_heading, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_1rotate_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_heading_difference_deg;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("rotate_heading (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_heading_difference_deg,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2279, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2279, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "rotate_heading", 0) < 0) __PYX_ERR(0, 2279, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("rotate_heading", 1, 1, 1, i); __PYX_ERR(0, 2279, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2279, __pyx_L3_error)
    }
    __pyx_v_heading_difference_deg = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_heading_difference_deg == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2279, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("rotate_heading", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2279, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.rotate_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_rotate_heading(__pyx_self, __pyx_v_heading_difference_deg);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_rotate_heading(PyObject *__pyx_self, double __pyx_v_heading_difference_deg) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_outer_scope;
  PyObject *__pyx_v_still_need_to_turn = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.rotate_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_still_need_to_turn);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2279, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_heading_difference_deg, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2279, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2279, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_1rotate_heading, 0, __pyx_mstate_global->__pyx_n_u_get_ship_maneuver_move_sequence, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2279, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_rotate_heading = __pyx_t_2;
  __pyx_t_2 = 0;

 2280:         nonlocal move_sequence

+2281:         if abs(heading_difference_deg) < GRAIN:

  __pyx_t_1 = fabs(__pyx_v_heading_difference_deg); 
  __pyx_t_2 = (__pyx_t_1 < __pyx_v_14neo_controller_GRAIN);
  if (__pyx_t_2) {
/* … */
  }

+2282:             return

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

+2283:         still_need_to_turn = heading_difference_deg

  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_still_need_to_turn = __pyx_t_3;
  __pyx_t_3 = 0;

+2284:         while abs(still_need_to_turn) > SHIP_MAX_TURN_RATE*DELTA_TIME:

  while (1) {
    __pyx_t_3 = __Pyx_PyNumber_Absolute(__pyx_v_still_need_to_turn); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2284, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2284, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2284, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2284, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2284, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2284, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (!__pyx_t_2) break;

+2285:             assert -SHIP_MAX_TURN_RATE <= SHIP_MAX_TURN_RATE*sign(heading_difference_deg) <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = PyNumber_Negative(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_8 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_4);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_8};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2285, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_6, __pyx_t_7, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2285, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_3)) {
        __Pyx_DECREF(__pyx_t_3);
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2285, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2285, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2285, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 2285, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 2285, __pyx_L1_error)
    #endif

+2286:             update(0.0, SHIP_MAX_TURN_RATE*sign(heading_difference_deg))

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_8};
      __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2286, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2286, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_update)) { __Pyx_RaiseClosureNameError("update"); __PYX_ERR(0, 2286, __pyx_L1_error) }
    __pyx_t_5 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_6update(__pyx_cur_scope->__pyx_v_update, 0.0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+2287:             still_need_to_turn -= SHIP_MAX_TURN_RATE*sign(heading_difference_deg)*DELTA_TIME

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6};
      __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2287, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __pyx_t_8 = PyNumber_Multiply(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_InPlaceSubtract(__pyx_v_still_need_to_turn, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2287, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF_SET(__pyx_v_still_need_to_turn, __pyx_t_7);
    __pyx_t_7 = 0;
  }

+2288:         if abs(still_need_to_turn) > EPS:

  __pyx_t_7 = __Pyx_PyNumber_Absolute(__pyx_v_still_need_to_turn); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2288, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2288, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2288, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2288, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_2) {
/* … */
  }

+2289:             assert -SHIP_MAX_TURN_RATE <= still_need_to_turn*FPS <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = PyNumber_Negative(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_7 = PyNumber_Multiply(__pyx_v_still_need_to_turn, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = PyObject_RichCompare(__pyx_t_5, __pyx_t_7, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2289, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_8)) {
        __Pyx_DECREF(__pyx_t_8);
        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2289, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2289, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2289, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 2289, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 2289, __pyx_L1_error)
    #endif

+2290:             update(0.0, still_need_to_turn*FPS)

    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2290, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = PyNumber_Multiply(__pyx_v_still_need_to_turn, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2290, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_1 = __Pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2290, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_update)) { __Pyx_RaiseClosureNameError("update"); __PYX_ERR(0, 2290, __pyx_L1_error) }
    __pyx_t_7 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_6update(__pyx_cur_scope->__pyx_v_update, 0.0, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2290, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

 2291: 

+2292:     def accelerate(target_speed: float, turn_rate: float) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_3accelerate(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_3accelerate = {"accelerate", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_3accelerate, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_3accelerate(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_target_speed;
  double __pyx_v_turn_rate;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("accelerate (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_target_speed,&__pyx_mstate_global->__pyx_n_u_turn_rate,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2292, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2292, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2292, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "accelerate", 0) < 0) __PYX_ERR(0, 2292, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("accelerate", 1, 2, 2, i); __PYX_ERR(0, 2292, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2292, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2292, __pyx_L3_error)
    }
    __pyx_v_target_speed = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_target_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2292, __pyx_L3_error)
    __pyx_v_turn_rate = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2292, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("accelerate", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2292, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.accelerate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_2accelerate(__pyx_self, __pyx_v_target_speed, __pyx_v_turn_rate);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_2accelerate(PyObject *__pyx_self, double __pyx_v_target_speed, double __pyx_v_turn_rate) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_outer_scope;
  PyObject *__pyx_v_drag = NULL;
  PyObject *__pyx_v_drag_amount = NULL;
  PyObject *__pyx_v_adjust_drag_by = NULL;
  PyObject *__pyx_v_delta_speed_to_target = NULL;
  PyObject *__pyx_v_thrust_amount = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.accelerate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_drag);
  __Pyx_XDECREF(__pyx_v_drag_amount);
  __Pyx_XDECREF(__pyx_v_adjust_drag_by);
  __Pyx_XDECREF(__pyx_v_delta_speed_to_target);
  __Pyx_XDECREF(__pyx_v_thrust_amount);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2292, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_target_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2292, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2292, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2292, __pyx_L1_error)
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_3accelerate, 0, __pyx_mstate_global->__pyx_n_u_get_ship_maneuver_move_sequence_2, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2292, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_1, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_accelerate = __pyx_t_1;
  __pyx_t_1 = 0;

 2293:         nonlocal move_sequence

 2294:         nonlocal ship_speed

 2295:         # Keep in mind speed can be negative

 2296:         # Drag will always slow down the ship

+2297:         while abs(target_speed - ship_speed) > EPS:

  while (1) {
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_target_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2297, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2297, __pyx_L1_error) }
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_1, __pyx_cur_scope->__pyx_v_ship_speed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2297, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyNumber_Absolute(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2297, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2297, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2297, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2297, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (!__pyx_t_4) break;

+2298:             drag = -SHIP_DRAG*sign(ship_speed)

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2298, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyNumber_Negative(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2298, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2298, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2298, __pyx_L1_error) }
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_cur_scope->__pyx_v_ship_speed};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2298, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2298, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_drag, __pyx_t_5);
    __pyx_t_5 = 0;

+2299:             drag_amount = SHIP_DRAG*DELTA_TIME

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2299, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2299, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyNumber_Multiply(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2299, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_drag_amount, __pyx_t_2);
    __pyx_t_2 = 0;

+2300:             if drag_amount > abs(ship_speed):

    if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2300, __pyx_L1_error) }
    __pyx_t_2 = __pyx_cur_scope->__pyx_v_ship_speed;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyNumber_Absolute(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyObject_RichCompare(__pyx_v_drag_amount, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2300, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2300, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_4) {
/* … */
    }

 2301:                 # The drag amount is reduced if it would make the ship cross 0 speed on its own

+2302:                 adjust_drag_by = abs((drag_amount - abs(ship_speed))*FPS)

      if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2302, __pyx_L1_error) }
      __pyx_t_2 = __pyx_cur_scope->__pyx_v_ship_speed;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_PyNumber_Absolute(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2302, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = PyNumber_Subtract(__pyx_v_drag_amount, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2302, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2302, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2302, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyNumber_Absolute(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2302, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF_SET(__pyx_v_adjust_drag_by, __pyx_t_3);
      __pyx_t_3 = 0;

+2303:                 drag -= adjust_drag_by*sign(drag)

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2303, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_2))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_drag};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2303, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_2 = PyNumber_Multiply(__pyx_v_adjust_drag_by, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2303, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyNumber_InPlaceSubtract(__pyx_v_drag, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2303, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF_SET(__pyx_v_drag, __pyx_t_3);
      __pyx_t_3 = 0;

+2304:             delta_speed_to_target = target_speed - ship_speed

    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_target_speed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2304, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2304, __pyx_L1_error) }
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_3, __pyx_cur_scope->__pyx_v_ship_speed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2304, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_delta_speed_to_target, __pyx_t_2);
    __pyx_t_2 = 0;

+2305:             thrust_amount = delta_speed_to_target*FPS - drag

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2305, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyNumber_Multiply(__pyx_v_delta_speed_to_target, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2305, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_3, __pyx_v_drag); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2305, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_thrust_amount, __pyx_t_2);
    __pyx_t_2 = 0;

+2306:             thrust_amount = min(max(-SHIP_MAX_THRUST, thrust_amount), SHIP_MAX_THRUST)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2306, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_v_thrust_amount);
    __pyx_t_3 = __pyx_v_thrust_amount;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2306, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_1 = PyNumber_Negative(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2306, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2306, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2306, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_4) {
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_5 = __pyx_t_3;
    } else {
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_5 = __pyx_t_1;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2306, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2306, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_4) {
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_5 = __pyx_t_2;
    } else {
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_5 = __pyx_t_3;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __pyx_t_5;
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF_SET(__pyx_v_thrust_amount, __pyx_t_2);
    __pyx_t_2 = 0;

+2307:             update(thrust_amount, turn_rate)

    __pyx_t_8 = __Pyx_PyFloat_AsDouble(__pyx_v_thrust_amount); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2307, __pyx_L1_error)
    if (unlikely(!__pyx_cur_scope->__pyx_v_update)) { __Pyx_RaiseClosureNameError("update"); __PYX_ERR(0, 2307, __pyx_L1_error) }
    __pyx_t_2 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_6update(__pyx_cur_scope->__pyx_v_update, __pyx_t_8, __pyx_v_turn_rate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  }

 2308: 

+2309:     def cruise(cruise_timesteps: int, cruise_turn_rate: float) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_5cruise(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_5cruise = {"cruise", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_5cruise, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_5cruise(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_cruise_timesteps = 0;
  double __pyx_v_cruise_turn_rate;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cruise (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_cruise_timesteps,&__pyx_mstate_global->__pyx_n_u_cruise_turn_rate,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2309, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2309, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2309, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "cruise", 0) < 0) __PYX_ERR(0, 2309, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("cruise", 1, 2, 2, i); __PYX_ERR(0, 2309, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2309, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2309, __pyx_L3_error)
    }
    __pyx_v_cruise_timesteps = ((PyObject*)values[0]);
    __pyx_v_cruise_turn_rate = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_cruise_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2309, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("cruise", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2309, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.cruise", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cruise_timesteps), (&PyLong_Type), 0, "cruise_timesteps", 2))) __PYX_ERR(0, 2309, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_4cruise(__pyx_self, __pyx_v_cruise_timesteps, __pyx_v_cruise_turn_rate);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_4cruise(PyObject *__pyx_self, PyObject *__pyx_v_cruise_timesteps, double __pyx_v_cruise_turn_rate) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_outer_scope;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.cruise", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2309, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_cruise_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2309, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2309, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2309, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_5cruise, 0, __pyx_mstate_global->__pyx_n_u_get_ship_maneuver_move_sequence_3, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2309, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_cruise = __pyx_t_2;
  __pyx_t_2 = 0;

 2310:         nonlocal move_sequence

 2311:         nonlocal ship_speed

 2312:         # Maintain current speed

+2313:         for _ in range(cruise_timesteps):

  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_range);
  __pyx_t_3 = __pyx_builtin_range; 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_cruise_timesteps};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2313, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2313, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2313, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  for (;;) {
    if (likely(!__pyx_t_6)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2313, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2313, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2313, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2313, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 2313, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v__, ((PyObject*)__pyx_t_1));
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+2314:             update(sign(ship_speed)*SHIP_DRAG, cruise_turn_rate)

    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2314, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2314, __pyx_L1_error) }
    __pyx_t_4 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_7))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
      __pyx_t_4 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_ship_speed};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2314, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2314, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2314, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_8 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2314, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_update)) { __Pyx_RaiseClosureNameError("update"); __PYX_ERR(0, 2314, __pyx_L1_error) }
    __pyx_t_2 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_6update(__pyx_cur_scope->__pyx_v_update, __pyx_t_8, __pyx_v_cruise_turn_rate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2314, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2315: 

+2316:     def update(thrust: float, turn_rate: float) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_7update(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_7update = {"update", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_7update, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_31get_ship_maneuver_move_sequence_7update(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_thrust;
  double __pyx_v_turn_rate;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("update (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_thrust,&__pyx_mstate_global->__pyx_n_u_turn_rate,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2316, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2316, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2316, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "update", 0) < 0) __PYX_ERR(0, 2316, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("update", 1, 2, 2, i); __PYX_ERR(0, 2316, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2316, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2316, __pyx_L3_error)
    }
    __pyx_v_thrust = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_thrust == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2316, __pyx_L3_error)
    __pyx_v_turn_rate = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2316, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("update", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2316, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.update", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_6update(__pyx_self, __pyx_v_thrust, __pyx_v_turn_rate);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_6update(PyObject *__pyx_self, double __pyx_v_thrust, double __pyx_v_turn_rate) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *__pyx_outer_scope;
  PyObject *__pyx_v_drag_amount = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_8_get_ship_maneuver_move_sequence *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.get_ship_maneuver_move_sequence.update", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_drag_amount);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2316, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2316, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2316, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 2316, __pyx_L1_error)
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_31get_ship_maneuver_move_sequence_7update, 0, __pyx_mstate_global->__pyx_n_u_get_ship_maneuver_move_sequence_4, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2316, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_1, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_update = __pyx_t_1;
  __pyx_t_1 = 0;

 2317:         nonlocal move_sequence

 2318:         nonlocal ship_speed

 2319:         # Apply drag. Fully stop the ship if it would cross zero speed in this time (prevents oscillation)

+2320:         drag_amount = SHIP_DRAG*DELTA_TIME

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_drag_amount = __pyx_t_3;
  __pyx_t_3 = 0;

+2321:         if drag_amount > abs(ship_speed):

  if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2321, __pyx_L1_error) }
  __pyx_t_3 = __pyx_cur_scope->__pyx_v_ship_speed;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyObject_RichCompare(__pyx_v_drag_amount, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2321, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2321, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_4) {
/* … */
    goto __pyx_L3;
  }

+2322:             ship_speed = 0.0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_ship_speed);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_mstate_global->__pyx_float_0_0);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_0_0);

 2323:         else:

+2324:             ship_speed -= drag_amount*sign(ship_speed)

  /*else*/ {
    if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2324, __pyx_L1_error) }
    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2324, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (unlikely(!__pyx_cur_scope->__pyx_v_ship_speed)) { __Pyx_RaiseClosureNameError("ship_speed"); __PYX_ERR(0, 2324, __pyx_L1_error) }
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_ship_speed};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2324, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_1 = PyNumber_Multiply(__pyx_v_drag_amount, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2324, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_InPlaceSubtract(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2324, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_ship_speed);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_3);
    __pyx_t_3 = 0;
  }
  __pyx_L3:;

 2325:         # Bounds check the thrust

+2326:         thrust = min(max(-SHIP_MAX_THRUST, thrust), SHIP_MAX_THRUST)

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __pyx_v_thrust;
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_7 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_4) {
    __pyx_t_8 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2326, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_1 = __pyx_t_8;
    __pyx_t_8 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_1 = __pyx_t_2;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2326, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_4) {
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = __pyx_t_3;
  } else {
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_1 = __pyx_t_2;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2326, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_thrust = __pyx_t_6;

 2327:         # Apply thrust

+2328:         ship_speed += thrust*DELTA_TIME

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_thrust); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ship_speed);
  __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_3);
  __pyx_t_3 = 0;

 2329:         # Bounds check the speed

+2330:         if ship_speed > SHIP_MAX_SPEED:

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2330, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2330, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_4) {
/* … */
    goto __pyx_L4;
  }

+2331:             ship_speed = SHIP_MAX_SPEED

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2331, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ship_speed);
    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_2);
    __Pyx_GIVEREF(__pyx_t_2);
    __pyx_t_2 = 0;

+2332:         elif ship_speed < -SHIP_MAX_SPEED:

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2332, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2332, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2332, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 2332, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_4) {
/* … */
  }
  __pyx_L4:;

+2333:             ship_speed = -SHIP_MAX_SPEED

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2333, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2333, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ship_speed);
    __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ship_speed, __pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_3);
    __pyx_t_3 = 0;

 2334:         #if not isclose(ship_starting_speed, 0.0):

 2335:             #print(f"New ship speed after thrusting by {thrust}: {ship_speed}")

+2336:         move_sequence.append(Action(thrust=thrust, turn_rate=turn_rate, fire=False))

  if (unlikely(!__pyx_cur_scope->__pyx_v_move_sequence)) { __Pyx_RaiseClosureNameError("move_sequence"); __PYX_ERR(0, 2336, __pyx_L1_error) }
  if (unlikely(__pyx_cur_scope->__pyx_v_move_sequence == Py_None)) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
    __PYX_ERR(0, 2336, __pyx_L1_error)
  }
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
  __pyx_t_1 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_thrust); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2336, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2336, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_5 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2336, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_t_8, __pyx_t_9, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2336, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_t_7, __pyx_t_9, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 2336, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, Py_False, __pyx_t_9, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 2336, __pyx_L1_error)
    __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_1, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2336, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_3);
  }
  __pyx_t_10 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_move_sequence, ((PyObject *)__pyx_t_3)); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 2336, __pyx_L1_error)
  __Pyx_DECREF((PyObject *)__pyx_t_3); __pyx_t_3 = 0;

 2337: 

+2338:     rotate_heading(ship_heading_angle)

  __pyx_t_1 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_rotate_heading(__pyx_v_rotate_heading, __pyx_v_ship_heading_angle); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2338, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2339:     accelerate(ship_cruise_speed, ship_accel_turn_rate)

  __pyx_t_1 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_2accelerate(__pyx_v_accelerate, __pyx_v_ship_cruise_speed, __pyx_v_ship_accel_turn_rate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2339, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2340:     cruise(ship_cruise_timesteps, ship_cruise_turn_rate)

  __pyx_t_1 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_4cruise(__pyx_v_cruise, __pyx_v_ship_cruise_timesteps, __pyx_v_ship_cruise_turn_rate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2340, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2341:     accelerate(0.0, 0.0)  # TODO: If we remove this, we get some interesting results and emergent behavior. Neo would spazz around the map, going from one maneuver directly into another. I might even be able to tweak it to work. Maybe in the stationary targeting, apply a thrust to slow down the ship, so the targeting works a bit better. That could fix the issue, and it might be worth exploring if I have time! But for now, let’s just eat the slight time loss and regain the control of node based movement without drifting around like driftwood.

  __pyx_t_1 = __pyx_pf_14neo_controller_31get_ship_maneuver_move_sequence_2accelerate(__pyx_v_accelerate, 0.0, 0.0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2341, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 2342:     #if not is_close(ship_starting_speed, 0.0):

 2343:     #    print(f"Interesting move sequence! The ship didn't start stationary. It had speed {ship_starting_speed}, and we used sequence {move_sequence} to return the ship to speed {ship_speed}")

+2344:     if not move_sequence:

  __pyx_t_3 = (__Pyx_PyList_GET_SIZE(__pyx_cur_scope->__pyx_v_move_sequence) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_3 < 0))) __PYX_ERR(0, 2344, __pyx_L1_error)
  __pyx_t_4 = (!__pyx_t_3);
  if (__pyx_t_4) {
/* … */
  }

 2345:         # We still need a null sequence here, so that we don't end up with a 0 frame maneuver!

+2346:         move_sequence.append(Action(thrust=0.0, turn_rate=0.0, fire=False))

    __pyx_t_2 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
    __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_2, NULL};
      __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2346, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_7, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2346, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_7, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 2346, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, Py_False, __pyx_t_7, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 2346, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2346, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_1);
    }
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_move_sequence, ((PyObject *)__pyx_t_1)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 2346, __pyx_L1_error)
    __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;

+2347:     return move_sequence

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_move_sequence);
  __pyx_r = __pyx_cur_scope->__pyx_v_move_sequence;
  goto __pyx_L0;

 2348: 

 2349: 

+2350: def analyze_gamestate_for_heuristic_maneuver(game_state: GameState, ship_state: Ship) -> tuple[float, float, float, float, int, float, int, int]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_87analyze_gamestate_for_heuristic_maneuver(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_87analyze_gamestate_for_heuristic_maneuver = {"analyze_gamestate_for_heuristic_maneuver", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_87analyze_gamestate_for_heuristic_maneuver, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_87analyze_gamestate_for_heuristic_maneuver(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("analyze_gamestate_for_heuristic_maneuver (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_ship_state,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2350, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2350, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "analyze_gamestate_for_heuristic_maneuver", 0) < 0) __PYX_ERR(0, 2350, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("analyze_gamestate_for_heuristic_maneuver", 1, 2, 2, i); __PYX_ERR(0, 2350, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2350, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2350, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("analyze_gamestate_for_heuristic_maneuver", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2350, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2350, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 2350, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_86analyze_gamestate_for_heuristic_maneuver(__pyx_self, __pyx_v_game_state, __pyx_v_ship_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_86analyze_gamestate_for_heuristic_maneuver(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver *__pyx_cur_scope;
  PyObject *__pyx_v_average_velocity = 0;
  PyObject *__pyx_v_find_largest_gap = 0;
  PyObject *__pyx_v_asteroids = NULL;
  PyObject *__pyx_v_other_ships = NULL;
  PyObject *__pyx_v_ship = NULL;
  PyObject *__pyx_v_ship_pos_x = NULL;
  PyObject *__pyx_v_ship_pos_y = NULL;
  PyObject *__pyx_v_ship_vel_x = NULL;
  PyObject *__pyx_v_ship_vel_y = NULL;
  PyObject *__pyx_v_most_imminent_collision_time_s = NULL;
  PyObject *__pyx_v_most_imminent_asteroid = NULL;
  PyObject *__pyx_v_most_imminent_asteroid_speed = NULL;
  double __pyx_v_nearby_asteroid_total_speed;
  PyObject *__pyx_v_nearby_asteroid_count = NULL;
  double __pyx_v_nearby_threshold_square;
  PyObject *__pyx_v_nearby_asteroids = NULL;
  PyObject *__pyx_v_asteroid = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_imminent_collision_time_s = NULL;
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  PyObject *__pyx_v_asteroid_speed = NULL;
  PyObject *__pyx_v_imminent_asteroid_relative_heading_deg = NULL;
  PyObject *__pyx_v_largest_gap_absolute_heading_rad = NULL;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_v_largest_gap_absolute_heading_deg = NULL;
  PyObject *__pyx_v_largest_gap_relative_heading_deg = NULL;
  PyObject *__pyx_v_nearby_asteroid_average_speed = NULL;
  PyObject *__pyx_v_average_directional_velocity = NULL;
  double __pyx_v_average_directional_speed;
  PyObject *__pyx_v_total_asteroid_count = NULL;
  PyObject *__pyx_v_current_asteroids_count = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver *)__pyx_tp_new_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 2350, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_average_velocity);
  __Pyx_XDECREF(__pyx_v_find_largest_gap);
  __Pyx_XDECREF(__pyx_v_asteroids);
  __Pyx_XDECREF(__pyx_v_other_ships);
  __Pyx_XDECREF(__pyx_v_ship);
  __Pyx_XDECREF(__pyx_v_ship_pos_x);
  __Pyx_XDECREF(__pyx_v_ship_pos_y);
  __Pyx_XDECREF(__pyx_v_ship_vel_x);
  __Pyx_XDECREF(__pyx_v_ship_vel_y);
  __Pyx_XDECREF(__pyx_v_most_imminent_collision_time_s);
  __Pyx_XDECREF(__pyx_v_most_imminent_asteroid);
  __Pyx_XDECREF(__pyx_v_most_imminent_asteroid_speed);
  __Pyx_XDECREF(__pyx_v_nearby_asteroid_count);
  __Pyx_XDECREF(__pyx_v_nearby_asteroids);
  __Pyx_XDECREF(__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_imminent_collision_time_s);
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_asteroid_speed);
  __Pyx_XDECREF(__pyx_v_imminent_asteroid_relative_heading_deg);
  __Pyx_XDECREF(__pyx_v_largest_gap_absolute_heading_rad);
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XDECREF(__pyx_v_largest_gap_absolute_heading_deg);
  __Pyx_XDECREF(__pyx_v_largest_gap_relative_heading_deg);
  __Pyx_XDECREF(__pyx_v_nearby_asteroid_average_speed);
  __Pyx_XDECREF(__pyx_v_average_directional_velocity);
  __Pyx_XDECREF(__pyx_v_total_asteroid_count);
  __Pyx_XDECREF(__pyx_v_current_asteroids_count);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2350, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 2350, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float_float_float_in) < 0) __PYX_ERR(0, 2350, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_87analyze_gamestate_for_heuristic_maneuver, 0, __pyx_mstate_global->__pyx_n_u_analyze_gamestate_for_heuristic_5, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[116])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_analyze_gamestate_for_heuristic_5, __pyx_t_4) < 0) __PYX_ERR(0, 2350, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver {
  PyObject_HEAD
  PyObject *__pyx_v_calculate_angular_width;
};

 2351:     # This is a helper function to analyze and prepare the gamestate, to give the maneuver FIS useful information, to heuristically command a maneuver to try out

+2352:     def calculate_angular_width(radius: float, distance: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_1calculate_angular_width(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_1calculate_angular_width = {"calculate_angular_width", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_1calculate_angular_width, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_1calculate_angular_width(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_radius;
  double __pyx_v_distance;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("calculate_angular_width (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_radius,&__pyx_mstate_global->__pyx_n_u_distance,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2352, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2352, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2352, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "calculate_angular_width", 0) < 0) __PYX_ERR(0, 2352, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("calculate_angular_width", 1, 2, 2, i); __PYX_ERR(0, 2352, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2352, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2352, __pyx_L3_error)
    }
    __pyx_v_radius = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2352, __pyx_L3_error)
    __pyx_v_distance = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_distance == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2352, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("calculate_angular_width", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2352, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.calculate_angular_width", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_calculate_angular_width(__pyx_self, __pyx_v_radius, __pyx_v_distance);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_calculate_angular_width(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_radius, double __pyx_v_distance) {
  double __pyx_v_sin_theta;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.calculate_angular_width", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_radius, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2352, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_distance, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2352, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2352, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_1calculate_angular_width, 0, __pyx_mstate_global->__pyx_n_u_analyze_gamestate_for_heuristic_2, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_cur_scope->__pyx_v_calculate_angular_width = __pyx_t_2;
  __pyx_t_2 = 0;

 2353:         # From the ship's point of view, find the angular width of an asteroid

+2354:         if distance == 0.0:

  __pyx_t_1 = (__pyx_v_distance == 0.0);
  if (__pyx_t_1) {
/* … */
  }

+2355:             return TAU

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2355, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+2356:         sin_theta = radius/distance

  if (unlikely(__pyx_v_distance == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 2356, __pyx_L1_error)
  }
  __pyx_v_sin_theta = (__pyx_v_radius / __pyx_v_distance);

+2357:         if -1.0 <= sin_theta <= 1.0:

  __pyx_t_1 = (-1.0 <= __pyx_v_sin_theta);
  if (__pyx_t_1) {
    __pyx_t_1 = (__pyx_v_sin_theta <= 1.0);
  }
  if (__pyx_t_1) {
/* … */
  }

+2358:             return 2.0*super_fast_asin(sin_theta)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_super_fast_asin); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2358, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2358, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2358, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_4 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_2_0, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2358, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 2359:         else:

+2360:             return TAU

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2360, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;
  }

 2361: 

+2362:     def average_velocity(asteroids: list[Asteroid]) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_3average_velocity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_3average_velocity = {"average_velocity", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_3average_velocity, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_3average_velocity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_asteroids = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("average_velocity (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroids,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2362, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2362, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "average_velocity", 0) < 0) __PYX_ERR(0, 2362, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("average_velocity", 1, 1, 1, i); __PYX_ERR(0, 2362, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2362, __pyx_L3_error)
    }
    __pyx_v_asteroids = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("average_velocity", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2362, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.average_velocity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids), (&PyList_Type), 0, "asteroids", 2))) __PYX_ERR(0, 2362, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_2average_velocity(__pyx_self, __pyx_v_asteroids);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_2average_velocity(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_asteroids) {
  double __pyx_v_total_x_velocity;
  double __pyx_v_total_y_velocity;
  PyObject *__pyx_v_a = NULL;
  __pyx_ctuple_double__and_double __pyx_v_ast_vel;
  PyObject *__pyx_v_num_asteroids = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.average_velocity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_num_asteroids);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2362, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2362, __pyx_L1_error)
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_3average_velocity, 0, __pyx_mstate_global->__pyx_n_u_analyze_gamestate_for_heuristic_3, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_1, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_average_velocity = __pyx_t_1;
  __pyx_t_1 = 0;

+2363:         total_x_velocity = 0.0

  __pyx_v_total_x_velocity = 0.0;

+2364:         total_y_velocity = 0.0

  __pyx_v_total_y_velocity = 0.0;

+2365:         for a in asteroids:

  __pyx_t_1 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2365, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2365, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2366:             ast_vel: tuple[float, float] = a.velocity

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2366, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __pyx_convert__from_py___pyx_ctuple_double__and_double(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2366, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_ast_vel = __pyx_t_4;

+2367:             total_x_velocity += ast_vel[0]

    __pyx_v_total_x_velocity = (__pyx_v_total_x_velocity + __pyx_v_ast_vel.f0);

+2368:             total_y_velocity += ast_vel[1]

    __pyx_v_total_y_velocity = (__pyx_v_total_y_velocity + __pyx_v_ast_vel.f1);

+2369:         num_asteroids = len(asteroids)

  __pyx_t_2 = __Pyx_PyList_GET_SIZE(__pyx_v_asteroids); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2369, __pyx_L1_error)
  __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_num_asteroids = __pyx_t_1;
  __pyx_t_1 = 0;

+2370:         if num_asteroids == 0.0:

  __pyx_t_5 = (__Pyx_PyFloat_BoolEqObjC(__pyx_v_num_asteroids, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 2370, __pyx_L1_error)
  if (__pyx_t_5) {
/* … */
  }

+2371:             return (0, 0)

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[10]);
    __pyx_r = __pyx_mstate_global->__pyx_tuple[10];
    goto __pyx_L0;

 2372:         else:

+2373:             return (total_x_velocity/num_asteroids, total_y_velocity/num_asteroids)

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_total_x_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2373, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_v_num_asteroids); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2373, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_total_y_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2373, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_v_num_asteroids); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2373, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2373, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 2373, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_6);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2373, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_t_6 = 0;
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

 2374: 

+2375:     def find_largest_gap(asteroids: list[Asteroid], ship_position: tuple[float, float]) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_5find_largest_gap(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_5find_largest_gap = {"find_largest_gap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_5find_largest_gap, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_5find_largest_gap(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_asteroids = 0;
  __pyx_ctuple_double__and_double __pyx_v_ship_position;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("find_largest_gap (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroids,&__pyx_mstate_global->__pyx_n_u_ship_position,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2375, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2375, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2375, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "find_largest_gap", 0) < 0) __PYX_ERR(0, 2375, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("find_largest_gap", 1, 2, 2, i); __PYX_ERR(0, 2375, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2375, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2375, __pyx_L3_error)
    }
    __pyx_v_asteroids = ((PyObject*)values[0]);
    __pyx_v_ship_position = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2375, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("find_largest_gap", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2375, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.find_largest_gap", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids), (&PyList_Type), 0, "asteroids", 2))) __PYX_ERR(0, 2375, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_4find_largest_gap(__pyx_self, __pyx_v_asteroids, __pyx_v_ship_position);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_4find_largest_gap(PyObject *__pyx_self, PyObject *__pyx_v_asteroids, __pyx_ctuple_double__and_double __pyx_v_ship_position) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver *__pyx_outer_scope;
  PyObject *__pyx_v_angles = 0;
  PyObject *__pyx_v_initial_cover_count = 0;
  PyObject *__pyx_v_asteroid = NULL;
  PyObject *__pyx_v_x = NULL;
  PyObject *__pyx_v_y = NULL;
  double __pyx_v_distance;
  PyObject *__pyx_v_angle = NULL;
  PyObject *__pyx_v_angular_width = NULL;
  PyObject *__pyx_v_start_angle = NULL;
  PyObject *__pyx_v_end_angle = NULL;
  PyObject *__pyx_v_counter = NULL;
  PyObject *__pyx_v_largest_gap_midpoint = NULL;
  PyObject *__pyx_v_largest_gap = NULL;
  PyObject *__pyx_v_gap_start = 0;
  PyObject *__pyx_v_marker = NULL;
  PyObject *__pyx_v_gap = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_9_analyze_gamestate_for_heuristic_maneuver *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.find_largest_gap", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_angles);
  __Pyx_XDECREF(__pyx_v_initial_cover_count);
  __Pyx_XDECREF(__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_v_x);
  __Pyx_XDECREF(__pyx_v_y);
  __Pyx_XDECREF(__pyx_v_angle);
  __Pyx_XDECREF(__pyx_v_angular_width);
  __Pyx_XDECREF(__pyx_v_start_angle);
  __Pyx_XDECREF(__pyx_v_end_angle);
  __Pyx_XDECREF(__pyx_v_counter);
  __Pyx_XDECREF(__pyx_v_largest_gap_midpoint);
  __Pyx_XDECREF(__pyx_v_largest_gap);
  __Pyx_XDECREF(__pyx_v_gap_start);
  __Pyx_XDECREF(__pyx_v_marker);
  __Pyx_XDECREF(__pyx_v_gap);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2375, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2375, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_position, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2375, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2375, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_5find_largest_gap, 0, __pyx_mstate_global->__pyx_n_u_analyze_gamestate_for_heuristic_4, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2375, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_find_largest_gap = __pyx_t_2;
  __pyx_t_2 = 0;

 2376:         # Find the largest angular gap around the ship, and this is the gap I'll try escaping through

+2377:         if not asteroids:

  __pyx_t_1 = (__Pyx_PyList_GET_SIZE(__pyx_v_asteroids) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 2377, __pyx_L1_error)
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

 2378:             # No asteroids mean the entire space is a gap.

+2379:             return 0.0, TAU

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2379, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2379, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_0_0);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_float_0_0) != (0)) __PYX_ERR(0, 2379, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2379, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 2380: 

+2381:         angles: list[tuple[float, bool]] = []

  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2381, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_v_angles = ((PyObject*)__pyx_t_4);
  __pyx_t_4 = 0;

+2382:         initial_cover_count: int = 0  # Counter for asteroids covering angle 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_initial_cover_count = __pyx_mstate_global->__pyx_int_0;

 2383: 

+2384:         for asteroid in asteroids:

  __pyx_t_4 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_4);
  __pyx_t_5 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2384, __pyx_L1_error)
      #endif
      if (__pyx_t_5 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_5);
    ++__pyx_t_5;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2384, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2385:             x = asteroid.position[0] - ship_position[0]

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ship_position.f0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = PyNumber_Subtract(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_x, __pyx_t_7);
    __pyx_t_7 = 0;

+2386:             y = asteroid.position[1] - ship_position[1]

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2386, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2386, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_ship_position.f1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2386, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = PyNumber_Subtract(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2386, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF_SET(__pyx_v_y, __pyx_t_6);
    __pyx_t_6 = 0;

+2387:             distance = sqrt(x*x + y*y)

    __pyx_t_6 = PyNumber_Multiply(__pyx_v_x, __pyx_v_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyNumber_Multiply(__pyx_v_y, __pyx_v_y); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = PyNumber_Add(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_8 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2387, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_distance = sqrt(__pyx_t_8);

+2388:             angle = super_fast_atan2(y, x) % TAU

    __pyx_t_7 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_super_fast_atan2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2388, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_7);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_v_y, __pyx_v_x};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2388, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2388, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyNumber_Remainder(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2388, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF_SET(__pyx_v_angle, __pyx_t_7);
    __pyx_t_7 = 0;

+2389:             angular_width = calculate_angular_width(asteroid.radius, distance)

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2389, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_calculate_angular_width)) { __Pyx_RaiseClosureNameError("calculate_angular_width"); __PYX_ERR(0, 2389, __pyx_L1_error) }
    __pyx_t_7 = __pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_calculate_angular_width(__pyx_cur_scope->__pyx_v_calculate_angular_width, __pyx_t_8, __pyx_v_distance); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_XDECREF_SET(__pyx_v_angular_width, __pyx_t_7);
    __pyx_t_7 = 0;

+2390:             start_angle = (angle - 0.5*angular_width) % TAU

    __pyx_t_7 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_0_5, __pyx_v_angular_width); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = PyNumber_Subtract(__pyx_v_angle, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = PyNumber_Remainder(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF_SET(__pyx_v_start_angle, __pyx_t_3);
    __pyx_t_3 = 0;

+2391:             end_angle = (angle + 0.5*angular_width) % TAU

    __pyx_t_3 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_0_5, __pyx_v_angular_width); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2391, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = PyNumber_Add(__pyx_v_angle, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2391, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2391, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = PyNumber_Remainder(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2391, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_end_angle, __pyx_t_6);
    __pyx_t_6 = 0;

 2392: 

 2393:             # Check if this asteroid covers the angle 0 (or equivalently, 2π)

+2394:             if start_angle > end_angle:  # This means the asteroid wraps around angle 0

    __pyx_t_6 = PyObject_RichCompare(__pyx_v_start_angle, __pyx_v_end_angle, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2394, __pyx_L1_error)
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2394, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_2) {
/* … */
    }

+2395:                 initial_cover_count += 1

      __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_v_initial_cover_count, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF_SET(__pyx_v_initial_cover_count, ((PyObject*)__pyx_t_6));
      __pyx_t_6 = 0;

 2396: 

 2397:             # Add angles in the original and offset positions

 2398:             # True is for start and False is for end

+2399:             angles.append((start_angle, True))

    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2399, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_v_start_angle);
    __Pyx_GIVEREF(__pyx_v_start_angle);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_start_angle) != (0)) __PYX_ERR(0, 2399, __pyx_L1_error);
    __Pyx_INCREF(Py_True);
    __Pyx_GIVEREF(Py_True);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, Py_True) != (0)) __PYX_ERR(0, 2399, __pyx_L1_error);
    __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_angles, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 2399, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+2400:             angles.append((end_angle, False))

    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2400, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_v_end_angle);
    __Pyx_GIVEREF(__pyx_v_end_angle);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_end_angle) != (0)) __PYX_ERR(0, 2400, __pyx_L1_error);
    __Pyx_INCREF(Py_False);
    __Pyx_GIVEREF(Py_False);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, Py_False) != (0)) __PYX_ERR(0, 2400, __pyx_L1_error);
    __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_angles, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 2400, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+2401:             angles.append((start_angle + TAU, True))

    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2401, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = PyNumber_Add(__pyx_v_start_angle, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2401, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2401, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 2401, __pyx_L1_error);
    __Pyx_INCREF(Py_True);
    __Pyx_GIVEREF(Py_True);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, Py_True) != (0)) __PYX_ERR(0, 2401, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_angles, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 2401, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+2402:             angles.append((end_angle + TAU, False))

    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2402, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = PyNumber_Add(__pyx_v_end_angle, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2402, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2402, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 2402, __pyx_L1_error);
    __Pyx_INCREF(Py_False);
    __Pyx_GIVEREF(Py_False);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, Py_False) != (0)) __PYX_ERR(0, 2402, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_angles, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 2402, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 2403: 

 2404:         # Sort by angle

+2405:         angles.sort(key=lambda x: x[0])

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_16find_largest_gap_lambda6(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_16find_largest_gap_lambda6 = {"lambda6", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_16find_largest_gap_lambda6, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_16find_largest_gap_lambda6(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_x = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda6 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2405, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2405, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda6", 0) < 0) __PYX_ERR(0, 2405, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda6", 1, 1, 1, i); __PYX_ERR(0, 2405, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2405, __pyx_L3_error)
    }
    __pyx_v_x = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("lambda6", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2405, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.find_largest_gap.lambda6", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_lambda_funcdef_lambda6(__pyx_self, __pyx_v_x);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_lambda_funcdef_lambda6(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.analyze_gamestate_for_heuristic_maneuver.find_largest_gap.lambda6", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_6 = __pyx_v_angles;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_16find_largest_gap_lambda6, 0, __pyx_mstate_global->__pyx_n_u_analyze_gamestate_for_heuristic, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, NULL};
    __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2405, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_3, __pyx_t_7, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2405, __pyx_L1_error)
    __pyx_t_4 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2405, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2406: 

 2407:         # Initialize counter with the number of asteroids covering angle 0

+2408:         counter = initial_cover_count

  __Pyx_INCREF(__pyx_v_initial_cover_count);
  __pyx_v_counter = __pyx_v_initial_cover_count;

+2409:         largest_gap_midpoint = 0.0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
  __pyx_v_largest_gap_midpoint = __pyx_mstate_global->__pyx_float_0_0;

+2410:         largest_gap = 0.0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
  __pyx_v_largest_gap = __pyx_mstate_global->__pyx_float_0_0;

+2411:         gap_start: Optional[float] = None

  __Pyx_INCREF(Py_None);
  __pyx_v_gap_start = ((PyObject*)Py_None);

 2412: 

+2413:         for angle, marker in angles:

  __pyx_t_4 = __pyx_v_angles; __Pyx_INCREF(__pyx_t_4);
  __pyx_t_5 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2413, __pyx_L1_error)
      #endif
      if (__pyx_t_5 >= __pyx_temp) break;
    }
    __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_5);
    ++__pyx_t_5;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 2413, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_3);
        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_6);
      } else {
        __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2413, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_3);
        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2413, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_6);
      }
      #else
      __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2413, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2413, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_11 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2413, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_11);
      index = 0; __pyx_t_3 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_3)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_3);
      index = 1; __pyx_t_6 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_6)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_11), 2) < 0) __PYX_ERR(0, 2413, __pyx_L1_error)
      __pyx_t_12 = NULL;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      goto __pyx_L11_unpacking_done;
      __pyx_L10_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_12 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 2413, __pyx_L1_error)
      __pyx_L11_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_angle, __pyx_t_3);
    __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_marker, __pyx_t_6);
    __pyx_t_6 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2414:             assert counter >= 0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_7 = PyObject_RichCompare(__pyx_v_counter, __pyx_mstate_global->__pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2414, __pyx_L1_error)
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2414, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 2414, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 2414, __pyx_L1_error)
    #endif

+2415:             if marker:

    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_marker); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2415, __pyx_L1_error)
    if (__pyx_t_2) {
/* … */
      goto __pyx_L12;
    }

 2416:                 # Start

+2417:                 if counter == 0 and gap_start is not None:

      __pyx_t_1 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_counter, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2417, __pyx_L1_error)
      if (__pyx_t_1) {
      } else {
        __pyx_t_2 = __pyx_t_1;
        goto __pyx_L14_bool_binop_done;
      }
      __pyx_t_1 = (__pyx_v_gap_start != ((PyObject*)Py_None));
      __pyx_t_2 = __pyx_t_1;
      __pyx_L14_bool_binop_done:;
      if (__pyx_t_2) {
/* … */
      }

 2418:                     # Calculate and check the gap size

+2419:                     gap = angle - gap_start

        __pyx_t_7 = PyNumber_Subtract(__pyx_v_angle, __pyx_v_gap_start); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2419, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_XDECREF_SET(__pyx_v_gap, __pyx_t_7);
        __pyx_t_7 = 0;

+2420:                     assert gap >= 0.0  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_7 = PyObject_RichCompare(__pyx_v_gap, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2420, __pyx_L1_error)
          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2420, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_2)) {
            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
            __PYX_ERR(0, 2420, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 2420, __pyx_L1_error)
        #endif

+2421:                     if gap > largest_gap:

        __pyx_t_7 = PyObject_RichCompare(__pyx_v_gap, __pyx_v_largest_gap, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2421, __pyx_L1_error)
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2421, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (__pyx_t_2) {
/* … */
        }

+2422:                         largest_gap = gap

          __Pyx_INCREF(__pyx_v_gap);
          __Pyx_DECREF_SET(__pyx_v_largest_gap, __pyx_v_gap);

+2423:                         largest_gap_midpoint = 0.5*(gap_start + angle) % TAU

          __pyx_t_7 = PyNumber_Add(__pyx_v_gap_start, __pyx_v_angle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2423, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_6 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_0_5, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2423, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_7 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2423, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_3 = PyNumber_Remainder(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2423, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF_SET(__pyx_v_largest_gap_midpoint, __pyx_t_3);
          __pyx_t_3 = 0;

+2424:                 counter += 1

      __pyx_t_3 = __Pyx_PyLong_AddObjC(__pyx_v_counter, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2424, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_counter, ((PyObject*)__pyx_t_3));
      __pyx_t_3 = 0;

 2425:             else:

 2426:                 # End

+2427:                 counter -= 1

    /*else*/ {
      __pyx_t_3 = __Pyx_PyLong_SubtractObjC(__pyx_v_counter, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2427, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_counter, ((PyObject*)__pyx_t_3));
      __pyx_t_3 = 0;

+2428:                 if counter == 0:

      __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_counter, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2428, __pyx_L1_error)
      if (__pyx_t_2) {
/* … */
      }
    }
    __pyx_L12:;

 2429:                     # Mark the start of a new gap

+2430:                     gap_start = angle

        __pyx_t_3 = __pyx_v_angle;
        __Pyx_INCREF(__pyx_t_3);
        if (!(likely(PyFloat_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("float", __pyx_t_3))) __PYX_ERR(0, 2430, __pyx_L1_error)
        __Pyx_DECREF_SET(__pyx_v_gap_start, ((PyObject*)__pyx_t_3));
        __pyx_t_3 = 0;

 2431: 

 2432:         # No need to adjust for wraparound explicitly due to "doubling" the angles list

+2433:         return largest_gap_midpoint, largest_gap

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2433, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_v_largest_gap_midpoint);
  __Pyx_GIVEREF(__pyx_v_largest_gap_midpoint);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_largest_gap_midpoint) != (0)) __PYX_ERR(0, 2433, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_largest_gap);
  __Pyx_GIVEREF(__pyx_v_largest_gap);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_largest_gap) != (0)) __PYX_ERR(0, 2433, __pyx_L1_error);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 2434: 

+2435:     asteroids = list(game_state.asteroids)

  __pyx_t_2 = PySequence_List(__pyx_v_game_state->asteroids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2435, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_asteroids = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+2436:     other_ships = []

  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2436, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_other_ships = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+2437:     for ship in game_state.ships:

  if (unlikely(__pyx_v_game_state->ships == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2437, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_v_game_state->ships; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2437, __pyx_L1_error)
      #endif
      if (__pyx_t_3 >= __pyx_temp) break;
    }
    __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3);
    ++__pyx_t_3;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2437, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_ship, __pyx_t_1);
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2438:         if ship.id != ship_state.id:

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2438, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_ship_state->id); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2438, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2438, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2438, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_6) {
/* … */
    }

+2439:             other_ships.append(ship)

      __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_other_ships, __pyx_v_ship); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 2439, __pyx_L1_error)

+2440:     for ship in other_ships:

  __pyx_t_2 = __pyx_v_other_ships; __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2440, __pyx_L1_error)
      #endif
      if (__pyx_t_3 >= __pyx_temp) break;
    }
    __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3);
    ++__pyx_t_3;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2440, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_ship, __pyx_t_5);
    __pyx_t_5 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2441:         # Fake ships as asteroids

 2442:         #asteroids.append({'position': ship.position, 'velocity': (0, 0), 'radius': ship.radius, 'size': -1, 'mass': -1.0})

+2443:         asteroids.append(Asteroid(position=ship.position, velocity=(0.0, 0.0), radius=ship.radius, size=-1, mass=-1.0))

    __pyx_t_4 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
    __pyx_t_1 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2443, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2443, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_4, NULL};
      __pyx_t_11 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2443, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_8, __pyx_t_11, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2443, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_tuple[0], __pyx_t_11, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 2443, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_t_9, __pyx_t_11, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 2443, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_mstate_global->__pyx_int_neg_1, __pyx_t_11, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 2443, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_mstate_global->__pyx_float_neg_1_0, __pyx_t_11, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 2443, __pyx_L1_error)
      __pyx_t_5 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_1, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_11);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2443, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_5);
    }
    __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_asteroids, ((PyObject *)__pyx_t_5)); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 2443, __pyx_L1_error)
    __Pyx_DECREF((PyObject *)__pyx_t_5); __pyx_t_5 = 0;

+2444:     ship_pos_x, ship_pos_y, ship_vel_x, ship_vel_y = ship_state.position[0], ship_state.position[1], ship_state.velocity[0], ship_state.velocity[1]

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_ship_pos_x = __pyx_t_5;
  __pyx_t_5 = 0;
  __pyx_v_ship_pos_y = __pyx_t_1;
  __pyx_t_1 = 0;
  __pyx_v_ship_vel_x = __pyx_t_11;
  __pyx_t_11 = 0;
  __pyx_v_ship_vel_y = __pyx_t_9;
  __pyx_t_9 = 0;

+2445:     most_imminent_collision_time_s = INFINITY

  __pyx_t_9 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2445, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_v_most_imminent_collision_time_s = __pyx_t_9;
  __pyx_t_9 = 0;

+2446:     most_imminent_asteroid = None

  __Pyx_INCREF(Py_None);
  __pyx_v_most_imminent_asteroid = Py_None;

+2447:     most_imminent_asteroid_speed = None

  __Pyx_INCREF(Py_None);
  __pyx_v_most_imminent_asteroid_speed = Py_None;

+2448:     nearby_asteroid_total_speed = 0.0

  __pyx_v_nearby_asteroid_total_speed = 0.0;

+2449:     nearby_asteroid_count = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_nearby_asteroid_count = __pyx_mstate_global->__pyx_int_0;

+2450:     nearby_threshold_square = 40000.0  # 200.0**2

  __pyx_v_nearby_threshold_square = 40000.0;

+2451:     nearby_asteroids = []

  __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2451, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_v_nearby_asteroids = ((PyObject*)__pyx_t_9);
  __pyx_t_9 = 0;

+2452:     for asteroid in asteroids:

  __pyx_t_9 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_9);
  __pyx_t_3 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2452, __pyx_L1_error)
      #endif
      if (__pyx_t_3 >= __pyx_temp) break;
    }
    __pyx_t_11 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_3);
    ++__pyx_t_3;
    if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2452, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_11);
    __pyx_t_11 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+2453:         for a in unwrap_asteroid(asteroid, game_state.map_size[0], game_state.map_size[1], UNWRAP_ASTEROID_COLLISION_FORECAST_TIME_HORIZON, False):

    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_unwrap_asteroid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2453, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2453, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2453, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2453, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2453, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_UNWRAP_ASTEROID_COLLISION_FORECA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2453, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[6] = {__pyx_t_1, __pyx_v_asteroid, __pyx_t_8, __pyx_t_4, __pyx_t_2, Py_False};
      __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (6-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2453, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
    }
    if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) {
      __pyx_t_5 = __pyx_t_11; __Pyx_INCREF(__pyx_t_5);
      __pyx_t_12 = 0;
      __pyx_t_13 = NULL;
    } else {
      __pyx_t_12 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2453, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2453, __pyx_L1_error)
    }
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    for (;;) {
      if (likely(!__pyx_t_13)) {
        if (likely(PyList_CheckExact(__pyx_t_5))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2453, __pyx_L1_error)
            #endif
            if (__pyx_t_12 >= __pyx_temp) break;
          }
          __pyx_t_11 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_12);
          ++__pyx_t_12;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2453, __pyx_L1_error)
            #endif
            if (__pyx_t_12 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_11 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_12));
          #else
          __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_12);
          #endif
          ++__pyx_t_12;
        }
        if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2453, __pyx_L1_error)
      } else {
        __pyx_t_11 = __pyx_t_13(__pyx_t_5);
        if (unlikely(!__pyx_t_11)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2453, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_11);
      __pyx_t_11 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+2454:             if is_close_to_zero(ship_vel_x) and is_close_to_zero(ship_vel_y):

      __pyx_t_2 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2454, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_2);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_ship_vel_x};
        __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2454, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
      }
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 2454, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (__pyx_t_14) {
      } else {
        __pyx_t_6 = __pyx_t_14;
        goto __pyx_L15_bool_binop_done;
      }
      __pyx_t_4 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2454, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_2))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
        assert(__pyx_t_4);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_ship_vel_y};
        __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2454, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
      }
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 2454, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_6 = __pyx_t_14;
      __pyx_L15_bool_binop_done:;
      if (__pyx_t_6) {
/* … */
        goto __pyx_L14;
      }

+2455:                 imminent_collision_time_s = predict_next_imminent_collision_time_with_asteroid(ship_pos_x, ship_pos_y, ship_vel_x, ship_vel_y, SHIP_RADIUS, a.position[0], a.position[1], a.velocity[0], a.velocity[1], a.radius, game_state)

        __pyx_t_2 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_predict_next_imminent_collision); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_16 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_16);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_17 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2455, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_2);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_2);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[12] = {__pyx_t_2, __pyx_v_ship_pos_x, __pyx_v_ship_pos_y, __pyx_v_ship_vel_x, __pyx_v_ship_vel_y, __pyx_t_8, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_1, ((PyObject *)__pyx_v_game_state)};
          __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_10, (12-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
          __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2455, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_11);
        }
        __Pyx_XDECREF_SET(__pyx_v_imminent_collision_time_s, __pyx_t_11);
        __pyx_t_11 = 0;

 2456:             else:

+2457:                 imminent_collision_time_s = INFINITY

      /*else*/ {
        __pyx_t_11 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2457, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_XDECREF_SET(__pyx_v_imminent_collision_time_s, __pyx_t_11);
        __pyx_t_11 = 0;
      }
      __pyx_L14:;

+2458:             delta_x = a.position[0] - ship_pos_x

      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2458, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_11, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2458, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = PyNumber_Subtract(__pyx_t_4, __pyx_v_ship_pos_x); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2458, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_11);
      __pyx_t_11 = 0;

+2459:             delta_y = a.position[1] - ship_pos_y

      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2459, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_11, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2459, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = PyNumber_Subtract(__pyx_t_4, __pyx_v_ship_pos_y); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2459, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_11);
      __pyx_t_11 = 0;

+2460:             asteroid_speed = None

      __Pyx_INCREF(Py_None);
      __Pyx_XDECREF_SET(__pyx_v_asteroid_speed, Py_None);

+2461:             if delta_x*delta_x + delta_y*delta_y <= nearby_threshold_square:

      __pyx_t_11 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2461, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_4 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2461, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = PyNumber_Add(__pyx_t_11, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2461, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_nearby_threshold_square); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2461, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_11 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_LE); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2461, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2461, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (__pyx_t_6) {
/* … */
      }

+2462:                 asteroid_speed = sqrt(a.velocity[0]*a.velocity[0] + a.velocity[1]*a.velocity[1])

        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_11, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_11, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __pyx_t_11 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyNumber_Multiply(__pyx_t_4, __pyx_t_18); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __pyx_t_18 = PyNumber_Add(__pyx_t_11, __pyx_t_1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_19 = __Pyx_PyFloat_AsDouble(__pyx_t_18); if (unlikely((__pyx_t_19 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __pyx_t_18 = PyFloat_FromDouble(sqrt(__pyx_t_19)); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_DECREF_SET(__pyx_v_asteroid_speed, __pyx_t_18);
        __pyx_t_18 = 0;

+2463:                 nearby_asteroid_total_speed += asteroid_speed

        __pyx_t_18 = PyFloat_FromDouble(__pyx_v_nearby_asteroid_total_speed); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2463, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_t_18, __pyx_v_asteroid_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2463, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __pyx_t_19 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_19 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2463, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_v_nearby_asteroid_total_speed = __pyx_t_19;

+2464:                 nearby_asteroid_count += 1

        __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_v_nearby_asteroid_count, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2464, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF_SET(__pyx_v_nearby_asteroid_count, __pyx_t_1);
        __pyx_t_1 = 0;

+2465:                 nearby_asteroids.append(a)

        __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_nearby_asteroids, __pyx_v_a); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 2465, __pyx_L1_error)

+2466:             if imminent_collision_time_s < most_imminent_collision_time_s:

      __pyx_t_1 = PyObject_RichCompare(__pyx_v_imminent_collision_time_s, __pyx_v_most_imminent_collision_time_s, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2466, __pyx_L1_error)
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2466, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__pyx_t_6) {
/* … */
      }

+2467:                 most_imminent_collision_time_s = imminent_collision_time_s

        __Pyx_INCREF(__pyx_v_imminent_collision_time_s);
        __Pyx_DECREF_SET(__pyx_v_most_imminent_collision_time_s, __pyx_v_imminent_collision_time_s);

+2468:                 most_imminent_asteroid = a

        __Pyx_INCREF(__pyx_v_a);
        __Pyx_DECREF_SET(__pyx_v_most_imminent_asteroid, __pyx_v_a);

+2469:                 if asteroid_speed is not None:

        __pyx_t_6 = (__pyx_v_asteroid_speed != Py_None);
        if (__pyx_t_6) {
/* … */
          goto __pyx_L19;
        }

+2470:                     most_imminent_asteroid_speed = asteroid_speed

          __Pyx_INCREF(__pyx_v_asteroid_speed);
          __Pyx_DECREF_SET(__pyx_v_most_imminent_asteroid_speed, __pyx_v_asteroid_speed);

 2471:                 else:

+2472:                     most_imminent_asteroid_speed = None

        /*else*/ {
          __Pyx_INCREF(Py_None);
          __Pyx_DECREF_SET(__pyx_v_most_imminent_asteroid_speed, Py_None);
        }
        __pyx_L19:;

+2473:     if most_imminent_asteroid is None:

  __pyx_t_6 = (__pyx_v_most_imminent_asteroid == Py_None);
  if (__pyx_t_6) {
/* … */
    goto __pyx_L22;
  }

+2474:         most_imminent_asteroid_speed = 0.0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __Pyx_DECREF_SET(__pyx_v_most_imminent_asteroid_speed, __pyx_mstate_global->__pyx_float_0_0);

+2475:         imminent_asteroid_relative_heading_deg = 0.0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_v_imminent_asteroid_relative_heading_deg = __pyx_mstate_global->__pyx_float_0_0;

 2476:     else:

+2477:         if most_imminent_asteroid_speed is None:

  /*else*/ {
    __pyx_t_6 = (__pyx_v_most_imminent_asteroid_speed == Py_None);
    if (__pyx_t_6) {
/* … */
    }

+2478:             most_imminent_asteroid_speed = sqrt(most_imminent_asteroid.velocity[0]*most_imminent_asteroid.velocity[0] + most_imminent_asteroid.velocity[1]*most_imminent_asteroid.velocity[1])

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyNumber_Multiply(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = PyNumber_Multiply(__pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __pyx_t_18 = PyNumber_Add(__pyx_t_9, __pyx_t_1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_19 = __Pyx_PyFloat_AsDouble(__pyx_t_18); if (unlikely((__pyx_t_19 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __pyx_t_18 = PyFloat_FromDouble(sqrt(__pyx_t_19)); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF_SET(__pyx_v_most_imminent_asteroid_speed, __pyx_t_18);
      __pyx_t_18 = 0;

+2479:         imminent_asteroid_relative_heading_deg = degrees(super_fast_atan2(most_imminent_asteroid.position[1] - ship_pos_y, most_imminent_asteroid.position[0] - ship_pos_x))

    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_11 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_super_fast_atan2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_16 = __Pyx_GetItemInt(__pyx_t_17, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __pyx_t_17 = PyNumber_Subtract(__pyx_t_16, __pyx_v_ship_pos_y); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_16, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __pyx_t_16 = PyNumber_Subtract(__pyx_t_15, __pyx_v_ship_pos_x); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2479, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_11);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_11);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_t_17, __pyx_t_16};
      __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2479, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_5};
      __pyx_t_18 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2479, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
    }
    __pyx_v_imminent_asteroid_relative_heading_deg = __pyx_t_18;
    __pyx_t_18 = 0;
  }
  __pyx_L22:;

 2480: 

+2481:     largest_gap_absolute_heading_rad, _ = find_largest_gap(nearby_asteroids, (ship_pos_x, ship_pos_y))

  __pyx_t_19 = __Pyx_PyFloat_AsDouble(__pyx_v_ship_pos_x); if (unlikely((__pyx_t_19 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2481, __pyx_L1_error)
  __pyx_t_20 = __Pyx_PyFloat_AsDouble(__pyx_v_ship_pos_y); if (unlikely((__pyx_t_20 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2481, __pyx_L1_error)
  __pyx_t_21.f0 = __pyx_t_19;
  __pyx_t_21.f1 = __pyx_t_20;
  __pyx_t_18 = __pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_4find_largest_gap(__pyx_v_find_largest_gap, __pyx_v_nearby_asteroids, __pyx_t_21); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2481, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  if ((likely(PyTuple_CheckExact(__pyx_t_18))) || (PyList_CheckExact(__pyx_t_18))) {
    PyObject* sequence = __pyx_t_18;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 2481, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_5);
    } else {
      __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2481, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_9);
      __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2481, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_5);
    }
    #else
    __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2481, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2481, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    #endif
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_1 = PyObject_GetIter(__pyx_t_18); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2481, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __pyx_t_22 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1);
    index = 0; __pyx_t_9 = __pyx_t_22(__pyx_t_1); if (unlikely(!__pyx_t_9)) goto __pyx_L24_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_9);
    index = 1; __pyx_t_5 = __pyx_t_22(__pyx_t_1); if (unlikely(!__pyx_t_5)) goto __pyx_L24_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_22(__pyx_t_1), 2) < 0) __PYX_ERR(0, 2481, __pyx_L1_error)
    __pyx_t_22 = NULL;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    goto __pyx_L25_unpacking_done;
    __pyx_L24_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_22 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 2481, __pyx_L1_error)
    __pyx_L25_unpacking_done:;
  }
  __pyx_v_largest_gap_absolute_heading_rad = __pyx_t_9;
  __pyx_t_9 = 0;
  __pyx_v__ = __pyx_t_5;
  __pyx_t_5 = 0;

+2482:     largest_gap_absolute_heading_deg = degrees(largest_gap_absolute_heading_rad)

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2482, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_10 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_largest_gap_absolute_heading_rad};
    __pyx_t_18 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2482, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
  }
  __pyx_v_largest_gap_absolute_heading_deg = __pyx_t_18;
  __pyx_t_18 = 0;

+2483:     largest_gap_relative_heading_deg = (largest_gap_absolute_heading_deg - ship_state.heading) % TAU

  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_ship_state->heading); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2483, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_9 = PyNumber_Subtract(__pyx_v_largest_gap_absolute_heading_deg, __pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2483, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2483, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_5 = PyNumber_Remainder(__pyx_t_9, __pyx_t_18); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2483, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_v_largest_gap_relative_heading_deg = __pyx_t_5;
  __pyx_t_5 = 0;

+2484:     if nearby_asteroid_count == 0:

  __pyx_t_6 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_nearby_asteroid_count, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2484, __pyx_L1_error)
  if (__pyx_t_6) {
/* … */
    goto __pyx_L26;
  }

+2485:         nearby_asteroid_average_speed = 0.0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_v_nearby_asteroid_average_speed = __pyx_mstate_global->__pyx_float_0_0;

 2486:     else:

+2487:         nearby_asteroid_average_speed = nearby_asteroid_total_speed/nearby_asteroid_count

  /*else*/ {
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_nearby_asteroid_total_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2487, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_18 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_v_nearby_asteroid_count); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2487, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_v_nearby_asteroid_average_speed = __pyx_t_18;
    __pyx_t_18 = 0;
  }
  __pyx_L26:;

 2488: 

+2489:     average_directional_velocity = average_velocity(asteroids)

  __pyx_t_18 = __pyx_pf_14neo_controller_40analyze_gamestate_for_heuristic_maneuver_2average_velocity(__pyx_v_average_velocity, __pyx_v_asteroids); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2489, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_v_average_directional_velocity = __pyx_t_18;
  __pyx_t_18 = 0;

+2490:     average_directional_speed = sqrt(average_directional_velocity[0]*average_directional_velocity[0] + average_directional_velocity[1]*average_directional_velocity[1])

  __pyx_t_18 = __Pyx_GetItemInt(__pyx_v_average_directional_velocity, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_average_directional_velocity, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = PyNumber_Multiply(__pyx_t_18, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_average_directional_velocity, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_18 = __Pyx_GetItemInt(__pyx_v_average_directional_velocity, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_t_18 = PyNumber_Add(__pyx_t_9, __pyx_t_1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_20 = __Pyx_PyFloat_AsDouble(__pyx_t_18); if (unlikely((__pyx_t_20 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2490, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __pyx_v_average_directional_speed = sqrt(__pyx_t_20);

+2491:     total_asteroid_count, current_asteroids_count = asteroid_counter(asteroids)

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroid_counter); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_10 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_asteroids};
    __pyx_t_18 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
  }
  if ((likely(PyTuple_CheckExact(__pyx_t_18))) || (PyList_CheckExact(__pyx_t_18))) {
    PyObject* sequence = __pyx_t_18;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 2491, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_1);
    } else {
      __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2491, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_9);
      __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2491, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_1);
    }
    #else
    __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    #endif
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_18); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __pyx_t_22 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5);
    index = 0; __pyx_t_9 = __pyx_t_22(__pyx_t_5); if (unlikely(!__pyx_t_9)) goto __pyx_L27_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_9);
    index = 1; __pyx_t_1 = __pyx_t_22(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L27_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_1);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_22(__pyx_t_5), 2) < 0) __PYX_ERR(0, 2491, __pyx_L1_error)
    __pyx_t_22 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L28_unpacking_done;
    __pyx_L27_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_22 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 2491, __pyx_L1_error)
    __pyx_L28_unpacking_done:;
  }
  __pyx_v_total_asteroid_count = __pyx_t_9;
  __pyx_t_9 = 0;
  __pyx_v_current_asteroids_count = __pyx_t_1;
  __pyx_t_1 = 0;

+2492:     return most_imminent_asteroid_speed, imminent_asteroid_relative_heading_deg, largest_gap_relative_heading_deg, nearby_asteroid_average_speed, nearby_asteroid_count, average_directional_speed, total_asteroid_count, current_asteroids_count

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_18 = PyFloat_FromDouble(__pyx_v_average_directional_speed); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2492, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_1 = PyTuple_New(8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2492, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_v_most_imminent_asteroid_speed);
  __Pyx_GIVEREF(__pyx_v_most_imminent_asteroid_speed);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_most_imminent_asteroid_speed) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_imminent_asteroid_relative_heading_deg);
  __Pyx_GIVEREF(__pyx_v_imminent_asteroid_relative_heading_deg);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_imminent_asteroid_relative_heading_deg) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_largest_gap_relative_heading_deg);
  __Pyx_GIVEREF(__pyx_v_largest_gap_relative_heading_deg);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_largest_gap_relative_heading_deg) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_nearby_asteroid_average_speed);
  __Pyx_GIVEREF(__pyx_v_nearby_asteroid_average_speed);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_nearby_asteroid_average_speed) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_nearby_asteroid_count);
  __Pyx_GIVEREF(__pyx_v_nearby_asteroid_count);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_v_nearby_asteroid_count) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_18);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_18) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_total_asteroid_count);
  __Pyx_GIVEREF(__pyx_v_total_asteroid_count);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_v_total_asteroid_count) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_current_asteroids_count);
  __Pyx_GIVEREF(__pyx_v_current_asteroids_count);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 7, __pyx_v_current_asteroids_count) != (0)) __PYX_ERR(0, 2492, __pyx_L1_error);
  __pyx_t_18 = 0;
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 2493: 

 2494: 

+2495: def check_collision(a_x: float, a_y: float, a_r: float, b_x: float, b_y: float, b_r: float) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_89check_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_89check_collision = {"check_collision", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_89check_collision, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_89check_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_a_x;
  double __pyx_v_a_y;
  double __pyx_v_a_r;
  double __pyx_v_b_x;
  double __pyx_v_b_y;
  double __pyx_v_b_r;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("check_collision (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_a_x,&__pyx_mstate_global->__pyx_n_u_a_y,&__pyx_mstate_global->__pyx_n_u_a_r,&__pyx_mstate_global->__pyx_n_u_b_x,&__pyx_mstate_global->__pyx_n_u_b_y,&__pyx_mstate_global->__pyx_n_u_b_r,0};
  PyObject* values[6] = {0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2495, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2495, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2495, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2495, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2495, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2495, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2495, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "check_collision", 0) < 0) __PYX_ERR(0, 2495, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 6; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("check_collision", 1, 6, 6, i); __PYX_ERR(0, 2495, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 6)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2495, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2495, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2495, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2495, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2495, __pyx_L3_error)
      values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2495, __pyx_L3_error)
    }
    __pyx_v_a_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_a_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L3_error)
    __pyx_v_a_y = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_a_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L3_error)
    __pyx_v_a_r = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_a_r == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L3_error)
    __pyx_v_b_x = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_b_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L3_error)
    __pyx_v_b_y = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_b_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L3_error)
    __pyx_v_b_r = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_b_r == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("check_collision", 1, 6, 6, __pyx_nargs); __PYX_ERR(0, 2495, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.check_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_88check_collision(__pyx_self, __pyx_v_a_x, __pyx_v_a_y, __pyx_v_a_r, __pyx_v_b_x, __pyx_v_b_y, __pyx_v_b_r);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_88check_collision(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_a_x, double __pyx_v_a_y, double __pyx_v_a_r, double __pyx_v_b_x, double __pyx_v_b_y, double __pyx_v_b_r) {
  double __pyx_v_delta_x;
  double __pyx_v_delta_y;
  double __pyx_v_separation;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2495, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a_r, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_b_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_b_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_b_r, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_89check_collision, 0, __pyx_mstate_global->__pyx_n_u_check_collision, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[117])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2495, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_check_collision, __pyx_t_2) < 0) __PYX_ERR(0, 2495, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2496:     # Since this is called so often, it's faster to inline this function instead of calling it

+2497:     delta_x = a_x - b_x

  __pyx_v_delta_x = (__pyx_v_a_x - __pyx_v_b_x);

+2498:     delta_y = a_y - b_y

  __pyx_v_delta_y = (__pyx_v_a_y - __pyx_v_b_y);

+2499:     separation = a_r + b_r

  __pyx_v_separation = (__pyx_v_a_r + __pyx_v_b_r);

 2500:     # Because most of the time the assumption is that there will be no collision, it's faster to do a quick rejection check, and only when it's possible for them to collide, we do the slightly more expensive squaring check

+2501:     if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

  __pyx_t_2 = fabs(__pyx_v_delta_x); 
  __pyx_t_3 = (__pyx_t_2 <= __pyx_v_separation);
  if (__pyx_t_3) {
  } else {
    __pyx_t_1 = __pyx_t_3;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = fabs(__pyx_v_delta_y); 
  __pyx_t_3 = (__pyx_t_2 <= __pyx_v_separation);
  if (__pyx_t_3) {
  } else {
    __pyx_t_1 = __pyx_t_3;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = (((__pyx_v_delta_x * __pyx_v_delta_x) + (__pyx_v_delta_y * __pyx_v_delta_y)) <= (__pyx_v_separation * __pyx_v_separation));
  __pyx_t_1 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+2502:         return True

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;

 2503:     else:

+2504:         return False

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;
  }

 2505: 

 2506: 

+2507: def collision_prediction(Oax: float, Oay: float, Dax: float, Day: float, ra: float, Obx: float, Oby: float, Dbx: float, Dby: float, rb: float) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_91collision_prediction(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_91collision_prediction = {"collision_prediction", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_91collision_prediction, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_91collision_prediction(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_Oax;
  double __pyx_v_Oay;
  double __pyx_v_Dax;
  double __pyx_v_Day;
  double __pyx_v_ra;
  double __pyx_v_Obx;
  double __pyx_v_Oby;
  double __pyx_v_Dbx;
  double __pyx_v_Dby;
  double __pyx_v_rb;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("collision_prediction (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_Oax,&__pyx_mstate_global->__pyx_n_u_Oay,&__pyx_mstate_global->__pyx_n_u_Dax,&__pyx_mstate_global->__pyx_n_u_Day,&__pyx_mstate_global->__pyx_n_u_ra,&__pyx_mstate_global->__pyx_n_u_Obx,&__pyx_mstate_global->__pyx_n_u_Oby,&__pyx_mstate_global->__pyx_n_u_Dbx,&__pyx_mstate_global->__pyx_n_u_Dby,&__pyx_mstate_global->__pyx_n_u_rb,0};
  PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2507, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2507, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "collision_prediction", 0) < 0) __PYX_ERR(0, 2507, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 10; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("collision_prediction", 1, 10, 10, i); __PYX_ERR(0, 2507, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 10)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2507, __pyx_L3_error)
      values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2507, __pyx_L3_error)
    }
    __pyx_v_Oax = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_Oax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_Oay = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_Oay == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_Dax = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_Dax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_Day = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_Day == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_ra = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_ra == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_Obx = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_Obx == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_Oby = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_Oby == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_Dbx = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_Dbx == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_Dby = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_Dby == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
    __pyx_v_rb = __Pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_rb == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2507, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("collision_prediction", 1, 10, 10, __pyx_nargs); __PYX_ERR(0, 2507, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.collision_prediction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_90collision_prediction(__pyx_self, __pyx_v_Oax, __pyx_v_Oay, __pyx_v_Dax, __pyx_v_Day, __pyx_v_ra, __pyx_v_Obx, __pyx_v_Oby, __pyx_v_Dbx, __pyx_v_Dby, __pyx_v_rb);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_90collision_prediction(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_Oax, double __pyx_v_Oay, double __pyx_v_Dax, double __pyx_v_Day, double __pyx_v_ra, double __pyx_v_Obx, double __pyx_v_Oby, double __pyx_v_Dbx, double __pyx_v_Dby, double __pyx_v_rb) {
  double __pyx_v_separation;
  double __pyx_v_delta_x;
  double __pyx_v_delta_y;
  double __pyx_v_vel_delta_x;
  double __pyx_v_vel_delta_y;
  double __pyx_v_a;
  double __pyx_v_b;
  double __pyx_v_c;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.collision_prediction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2507, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Oax, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Oay, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Dax, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Day, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ra, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Obx, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Oby, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Dbx, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Dby, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_rb, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_91collision_prediction, 0, __pyx_mstate_global->__pyx_n_u_collision_prediction, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[118])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2507, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_collision_prediction, __pyx_t_4) < 0) __PYX_ERR(0, 2507, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2508:     # Given two circles moving at constant velocities, will they collide, and when? This can be solved in constant time with a calculation

 2509:     # https://stackoverflow.com/questions/11369616/circle-circle-collision-prediction/

+2510:     separation = ra + rb

  __pyx_v_separation = (__pyx_v_ra + __pyx_v_rb);

+2511:     delta_x = Oax - Obx

  __pyx_v_delta_x = (__pyx_v_Oax - __pyx_v_Obx);

+2512:     delta_y = Oay - Oby

  __pyx_v_delta_y = (__pyx_v_Oay - __pyx_v_Oby);

+2513:     if is_close_to_zero(Dax) and is_close_to_zero(Day) and is_close_to_zero(Dbx) and is_close_to_zero(Dby):

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_Dax); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2513, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_7) {
  } else {
    __pyx_t_1 = __pyx_t_7;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_Day); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2513, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_7) {
  } else {
    __pyx_t_1 = __pyx_t_7;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_Dbx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2513, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_7) {
  } else {
    __pyx_t_1 = __pyx_t_7;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_Dby); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2513, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2513, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_1 = __pyx_t_7;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 2514:         # If both objects are stationary, then we only have to check the collision right now and not do any fancy math

 2515:         # This should speed up scenarios where most asteroids are stationary

 2516:         #if check_collision(Oax, Oay, ra, Obx, Oby, rb):

+2517:         if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

    __pyx_t_8 = fabs(__pyx_v_delta_x); 
    __pyx_t_7 = (__pyx_t_8 <= __pyx_v_separation);
    if (__pyx_t_7) {
    } else {
      __pyx_t_1 = __pyx_t_7;
      goto __pyx_L9_bool_binop_done;
    }
    __pyx_t_8 = fabs(__pyx_v_delta_y); 
    __pyx_t_7 = (__pyx_t_8 <= __pyx_v_separation);
    if (__pyx_t_7) {
    } else {
      __pyx_t_1 = __pyx_t_7;
      goto __pyx_L9_bool_binop_done;
    }
    __pyx_t_7 = (((__pyx_v_delta_x * __pyx_v_delta_x) + (__pyx_v_delta_y * __pyx_v_delta_y)) <= (__pyx_v_separation * __pyx_v_separation));
    __pyx_t_1 = __pyx_t_7;
    __pyx_L9_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+2518:             return -INFINITY, INFINITY

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_2 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2518, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_4 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2518, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2518, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GIVEREF(__pyx_t_2);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2518, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2518, __pyx_L1_error);
      __pyx_t_2 = 0;
      __pyx_t_4 = 0;
      __pyx_r = __pyx_t_5;
      __pyx_t_5 = 0;
      goto __pyx_L0;

 2519:         else:

+2520:             return NAN, NAN

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_5 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2520, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2520, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2520, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_GIVEREF(__pyx_t_5);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 2520, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2520, __pyx_L1_error);
      __pyx_t_5 = 0;
      __pyx_t_4 = 0;
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;
    }

 2521:     else:

 2522:         # Compared to the stack overflow, the following has been factored to reduce intermediate computations and save some clock cycles

+2523:         vel_delta_x = Dax - Dbx

  /*else*/ {
    __pyx_v_vel_delta_x = (__pyx_v_Dax - __pyx_v_Dbx);

+2524:         vel_delta_y = Day - Dby

    __pyx_v_vel_delta_y = (__pyx_v_Day - __pyx_v_Dby);

+2525:         a = vel_delta_x*vel_delta_x + vel_delta_y*vel_delta_y

    __pyx_v_a = ((__pyx_v_vel_delta_x * __pyx_v_vel_delta_x) + (__pyx_v_vel_delta_y * __pyx_v_vel_delta_y));

+2526:         b = 2.0*(delta_x*vel_delta_x + delta_y*vel_delta_y)

    __pyx_v_b = (2.0 * ((__pyx_v_delta_x * __pyx_v_vel_delta_x) + (__pyx_v_delta_y * __pyx_v_vel_delta_y)));

+2527:         c = delta_x*delta_x + delta_y*delta_y - separation*separation

    __pyx_v_c = (((__pyx_v_delta_x * __pyx_v_delta_x) + (__pyx_v_delta_y * __pyx_v_delta_y)) - (__pyx_v_separation * __pyx_v_separation));

+2528:         return solve_quadratic(a, b, c)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_solve_quadratic); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2528, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2528, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_9 = PyFloat_FromDouble(__pyx_v_b); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2528, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = PyFloat_FromDouble(__pyx_v_c); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2528, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_t_3, __pyx_t_9, __pyx_t_10};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2528, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;
  }

 2529: 

 2530: 

+2531: def predict_next_imminent_collision_time_with_asteroid(ship_pos_x: float, ship_pos_y: float, ship_vel_x: float, ship_vel_y: float, ship_r: float, ast_pos_x: float, ast_pos_y: float, ast_vel_x: float, ast_vel_y: float, ast_radius: float, game_state: GameState) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_93predict_next_imminent_collision_time_with_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_93predict_next_imminent_collision_time_with_asteroid = {"predict_next_imminent_collision_time_with_asteroid", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_93predict_next_imminent_collision_time_with_asteroid, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_93predict_next_imminent_collision_time_with_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_ship_pos_x;
  double __pyx_v_ship_pos_y;
  double __pyx_v_ship_vel_x;
  double __pyx_v_ship_vel_y;
  double __pyx_v_ship_r;
  double __pyx_v_ast_pos_x;
  double __pyx_v_ast_pos_y;
  double __pyx_v_ast_vel_x;
  double __pyx_v_ast_vel_y;
  double __pyx_v_ast_radius;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("predict_next_imminent_collision_time_with_asteroid (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ship_pos_x,&__pyx_mstate_global->__pyx_n_u_ship_pos_y,&__pyx_mstate_global->__pyx_n_u_ship_vel_x,&__pyx_mstate_global->__pyx_n_u_ship_vel_y,&__pyx_mstate_global->__pyx_n_u_ship_r,&__pyx_mstate_global->__pyx_n_u_ast_pos_x,&__pyx_mstate_global->__pyx_n_u_ast_pos_y,&__pyx_mstate_global->__pyx_n_u_ast_vel_x,&__pyx_mstate_global->__pyx_n_u_ast_vel_y,&__pyx_mstate_global->__pyx_n_u_ast_radius,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2531, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case 11:
        values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2531, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "predict_next_imminent_collision_time_with_asteroid", 0) < 0) __PYX_ERR(0, 2531, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 11; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("predict_next_imminent_collision_time_with_asteroid", 1, 11, 11, i); __PYX_ERR(0, 2531, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 11)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2531, __pyx_L3_error)
      values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2531, __pyx_L3_error)
    }
    __pyx_v_ship_pos_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_ship_pos_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ship_pos_y = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_ship_pos_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ship_vel_x = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ship_vel_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ship_vel_y = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ship_vel_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ship_r = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_ship_r == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ast_pos_x = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_ast_pos_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ast_pos_y = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_ast_pos_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ast_vel_x = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_ast_vel_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ast_vel_y = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_ast_vel_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_ast_radius = __Pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_ast_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2531, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[10]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("predict_next_imminent_collision_time_with_asteroid", 1, 11, 11, __pyx_nargs); __PYX_ERR(0, 2531, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.predict_next_imminent_collision_time_with_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2531, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_92predict_next_imminent_collision_time_with_asteroid(__pyx_self, __pyx_v_ship_pos_x, __pyx_v_ship_pos_y, __pyx_v_ship_vel_x, __pyx_v_ship_vel_y, __pyx_v_ship_r, __pyx_v_ast_pos_x, __pyx_v_ast_pos_y, __pyx_v_ast_vel_x, __pyx_v_ast_vel_y, __pyx_v_ast_radius, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_92predict_next_imminent_collision_time_with_asteroid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_ship_pos_x, double __pyx_v_ship_pos_y, double __pyx_v_ship_vel_x, double __pyx_v_ship_vel_y, double __pyx_v_ship_r, double __pyx_v_ast_pos_x, double __pyx_v_ast_pos_y, double __pyx_v_ast_vel_x, double __pyx_v_ast_vel_y, double __pyx_v_ast_radius, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_start_collision_time = NULL;
  PyObject *__pyx_v_end_collision_time = NULL;
  PyObject *__pyx_v_t1 = NULL;
  PyObject *__pyx_v_t2 = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_AddTraceback("neo_controller.predict_next_imminent_collision_time_with_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_start_collision_time);
  __Pyx_XDECREF(__pyx_v_end_collision_time);
  __Pyx_XDECREF(__pyx_v_t1);
  __Pyx_XDECREF(__pyx_v_t2);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_pos_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_pos_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_vel_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_vel_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_r, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ast_pos_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ast_pos_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ast_vel_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ast_vel_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ast_radius, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_93predict_next_imminent_collision_time_with_asteroid, 0, __pyx_mstate_global->__pyx_n_u_predict_next_imminent_collision, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[119])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_predict_next_imminent_collision, __pyx_t_2) < 0) __PYX_ERR(0, 2531, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2532:     # print("ship_pos_x, ship_pos_y, ship_vel_x, ship_vel_y, ship_r, ast_pos_x, ast_pos_y, ast_vel_x, ast_vel_y, ast_radius")

 2533:     # print(ship_pos_x, ship_pos_y, ship_vel_x, ship_vel_y, ship_r, ast_pos_x, ast_pos_y, ast_vel_x, ast_vel_y, ast_radius)

+2534:     assert is_close_to_zero(ship_vel_x) and is_close_to_zero(ship_vel_y)  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2534, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_ship_vel_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2534, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2534, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2534, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_7) {
    } else {
      __pyx_t_1 = __pyx_t_7;
      goto __pyx_L3_bool_binop_done;
    }
    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2534, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ship_vel_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2534, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2534, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2534, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_1 = __pyx_t_7;
    __pyx_L3_bool_binop_done:;
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 2534, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 2534, __pyx_L1_error)
  #endif

+2535:     assert check_coordinate_bounds(game_state, ship_pos_x, ship_pos_y)  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2535, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ship_pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2535, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_8 = PyFloat_FromDouble(__pyx_v_ship_pos_y); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2535, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_5, ((PyObject *)__pyx_v_game_state), __pyx_t_4, __pyx_t_8};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2535, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2535, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 2535, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 2535, __pyx_L1_error)
  #endif

+2536:     start_collision_time, end_collision_time = collision_prediction(ship_pos_x, ship_pos_y, ship_vel_x, ship_vel_y, ship_r, ast_pos_x, ast_pos_y, ast_vel_x, ast_vel_y, ast_radius)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_collision_prediction); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ship_pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_ship_pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_ship_vel_x); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_ship_vel_y); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_11 = PyFloat_FromDouble(__pyx_v_ship_r); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_12 = PyFloat_FromDouble(__pyx_v_ast_pos_x); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = PyFloat_FromDouble(__pyx_v_ast_pos_y); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_14 = PyFloat_FromDouble(__pyx_v_ast_vel_x); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_15 = PyFloat_FromDouble(__pyx_v_ast_vel_y); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_16 = PyFloat_FromDouble(__pyx_v_ast_radius); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[11] = {__pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (11-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2536, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
    PyObject* sequence = __pyx_t_2;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 2536, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_16 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_16);
    } else {
      __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2536, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_8);
      __pyx_t_16 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2536, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_16);
    }
    #else
    __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2536, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_16 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2536, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    #endif
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_15 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2536, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_15);
    index = 0; __pyx_t_8 = __pyx_t_17(__pyx_t_15); if (unlikely(!__pyx_t_8)) goto __pyx_L5_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_8);
    index = 1; __pyx_t_16 = __pyx_t_17(__pyx_t_15); if (unlikely(!__pyx_t_16)) goto __pyx_L5_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_16);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_15), 2) < 0) __PYX_ERR(0, 2536, __pyx_L1_error)
    __pyx_t_17 = NULL;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    goto __pyx_L6_unpacking_done;
    __pyx_L5_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_t_17 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 2536, __pyx_L1_error)
    __pyx_L6_unpacking_done:;
  }
  __pyx_v_start_collision_time = __pyx_t_8;
  __pyx_t_8 = 0;
  __pyx_v_end_collision_time = __pyx_t_16;
  __pyx_t_16 = 0;

 2537:     # If we're already colliding with something, then return 0 as the next imminent collision time

+2538:     if isnan(start_collision_time) or isnan(end_collision_time):

  __pyx_t_18 = __Pyx_PyFloat_AsDouble(__pyx_v_start_collision_time); if (unlikely((__pyx_t_18 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2538, __pyx_L1_error)
  __pyx_t_7 = isnan(__pyx_t_18);
  if (!__pyx_t_7) {
  } else {
    __pyx_t_1 = __pyx_t_7;
    goto __pyx_L8_bool_binop_done;
  }
  __pyx_t_18 = __Pyx_PyFloat_AsDouble(__pyx_v_end_collision_time); if (unlikely((__pyx_t_18 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2538, __pyx_L1_error)
  __pyx_t_7 = isnan(__pyx_t_18);
  __pyx_t_1 = __pyx_t_7;
  __pyx_L8_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+2539:         return INFINITY

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2539, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

 2540:     else:

+2541:         assert start_collision_time <= end_collision_time  # REMOVE_FOR_COMPETITION

  /*else*/ {
    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_2 = PyObject_RichCompare(__pyx_v_start_collision_time, __pyx_v_end_collision_time, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2541, __pyx_L1_error)
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2541, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 2541, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 2541, __pyx_L1_error)
    #endif

+2542:         if not (SHIP_RADIUS_PLUS_SIZE_4_ASTEROID_RADIUS < ship_pos_x < game_state.map_size[0] - SHIP_RADIUS_PLUS_SIZE_4_ASTEROID_RADIUS and SHIP_RADIUS_PLUS_SIZE_4_ASTEROID_RADIUS < ship_pos_y < game_state.map_size[1] - SHIP_RADIUS_PLUS_SIZE_4_ASTEROID_RADIUS):

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS_PLUS_SIZE_4_ASTEROID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_16 = PyFloat_FromDouble(__pyx_v_ship_pos_x); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_2, __pyx_t_16, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2542, __pyx_L1_error)
    if (__Pyx_PyObject_IsTrue(__pyx_t_8)) {
      __Pyx_DECREF(__pyx_t_8);
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_14 = __Pyx_GetItemInt(__pyx_t_15, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS_PLUS_SIZE_4_ASTEROID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_13 = PyNumber_Subtract(__pyx_t_14, __pyx_t_15); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_8 = PyObject_RichCompare(__pyx_t_16, __pyx_t_13, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2542, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_7) {
    } else {
      __pyx_t_1 = __pyx_t_7;
      goto __pyx_L11_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS_PLUS_SIZE_4_ASTEROID); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_16 = PyFloat_FromDouble(__pyx_v_ship_pos_y); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_8, __pyx_t_16, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2542, __pyx_L1_error)
    if (__Pyx_PyObject_IsTrue(__pyx_t_2)) {
      __Pyx_DECREF(__pyx_t_2);
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_13, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS_PLUS_SIZE_4_ASTEROID); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_14 = PyNumber_Subtract(__pyx_t_15, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_2 = PyObject_RichCompare(__pyx_t_16, __pyx_t_14, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2542, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    }
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2542, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_1 = __pyx_t_7;
    __pyx_L11_bool_binop_done:;
    __pyx_t_7 = (!__pyx_t_1);
    if (__pyx_t_7) {
/* … */
    }

 2543:             # There's the possibility that this isn't a true collision, because the asteroid could have been on the other side of the border, so it never actually hit the ship.

 2544:             # We need to find the time interval in which the asteroid is in the main game area, and see whether the collision time intersects with this time interval.

+2545:             t1, t2 = find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap(ast_pos_x, ast_pos_y, ast_vel_x, ast_vel_y, game_state)

      __pyx_t_16 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_find_time_interval_in_which_unwr); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_14 = PyFloat_FromDouble(__pyx_v_ast_pos_x); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_13 = PyFloat_FromDouble(__pyx_v_ast_pos_y); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_15 = PyFloat_FromDouble(__pyx_v_ast_vel_x); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_12 = PyFloat_FromDouble(__pyx_v_ast_vel_y); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_8))) {
        __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_8);
        assert(__pyx_t_16);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
        __Pyx_INCREF(__pyx_t_16);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[6] = {__pyx_t_16, __pyx_t_14, __pyx_t_13, __pyx_t_15, __pyx_t_12, ((PyObject *)__pyx_v_game_state)};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (6-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2545, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
        PyObject* sequence = __pyx_t_2;
        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
        if (unlikely(size != 2)) {
          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
          __PYX_ERR(0, 2545, __pyx_L1_error)
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        if (likely(PyTuple_CheckExact(sequence))) {
          __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0);
          __Pyx_INCREF(__pyx_t_8);
          __pyx_t_12 = PyTuple_GET_ITEM(sequence, 1);
          __Pyx_INCREF(__pyx_t_12);
        } else {
          __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 0);
          if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2545, __pyx_L1_error)
          __Pyx_XGOTREF(__pyx_t_8);
          __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 1);
          if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2545, __pyx_L1_error)
          __Pyx_XGOTREF(__pyx_t_12);
        }
        #else
        __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2545, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_12 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2545, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_12);
        #endif
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      } else {
        Py_ssize_t index = -1;
        __pyx_t_15 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2545, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_15);
        index = 0; __pyx_t_8 = __pyx_t_17(__pyx_t_15); if (unlikely(!__pyx_t_8)) goto __pyx_L13_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_8);
        index = 1; __pyx_t_12 = __pyx_t_17(__pyx_t_15); if (unlikely(!__pyx_t_12)) goto __pyx_L13_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_12);
        if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_15), 2) < 0) __PYX_ERR(0, 2545, __pyx_L1_error)
        __pyx_t_17 = NULL;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        goto __pyx_L14_unpacking_done;
        __pyx_L13_unpacking_failed:;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_17 = NULL;
        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
        __PYX_ERR(0, 2545, __pyx_L1_error)
        __pyx_L14_unpacking_done:;
      }
      __pyx_v_t1 = __pyx_t_8;
      __pyx_t_8 = 0;
      __pyx_v_t2 = __pyx_t_12;
      __pyx_t_12 = 0;

 2546:             # Find the intersection in the collision period and where the collision is within the main wrap

+2547:             if end_collision_time < t1 or start_collision_time > t2:

      __pyx_t_2 = PyObject_RichCompare(__pyx_v_end_collision_time, __pyx_v_t1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2547, __pyx_L1_error)
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2547, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (!__pyx_t_1) {
      } else {
        __pyx_t_7 = __pyx_t_1;
        goto __pyx_L16_bool_binop_done;
      }
      __pyx_t_2 = PyObject_RichCompare(__pyx_v_start_collision_time, __pyx_v_t2, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2547, __pyx_L1_error)
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2547, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_7 = __pyx_t_1;
      __pyx_L16_bool_binop_done:;
      if (__pyx_t_7) {
/* … */
      }

 2548:                 # There is no intersection! The collision never occurs.

+2549:                 return INFINITY

        __Pyx_XDECREF(__pyx_r);
        __pyx_t_2 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2549, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        goto __pyx_L0;

 2550:             else:

+2551:                 start_collision_time = max(start_collision_time, t1)

      /*else*/ {
        __Pyx_INCREF(__pyx_v_t1);
        __pyx_t_2 = __pyx_v_t1;
        __Pyx_INCREF(__pyx_v_start_collision_time);
        __pyx_t_12 = __pyx_v_start_collision_time;
        __pyx_t_15 = PyObject_RichCompare(__pyx_t_2, __pyx_t_12, Py_GT); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2551, __pyx_L1_error)
        __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2551, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        if (__pyx_t_7) {
          __Pyx_INCREF(__pyx_t_2);
          __pyx_t_8 = __pyx_t_2;
        } else {
          __Pyx_INCREF(__pyx_t_12);
          __pyx_t_8 = __pyx_t_12;
        }
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = __pyx_t_8;
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF_SET(__pyx_v_start_collision_time, __pyx_t_2);
        __pyx_t_2 = 0;

+2552:                 end_collision_time = min(end_collision_time, t2)

        __Pyx_INCREF(__pyx_v_t2);
        __pyx_t_2 = __pyx_v_t2;
        __Pyx_INCREF(__pyx_v_end_collision_time);
        __pyx_t_8 = __pyx_v_end_collision_time;
        __pyx_t_15 = PyObject_RichCompare(__pyx_t_2, __pyx_t_8, Py_LT); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2552, __pyx_L1_error)
        __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2552, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        if (__pyx_t_7) {
          __Pyx_INCREF(__pyx_t_2);
          __pyx_t_12 = __pyx_t_2;
        } else {
          __Pyx_INCREF(__pyx_t_8);
          __pyx_t_12 = __pyx_t_8;
        }
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = __pyx_t_12;
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF_SET(__pyx_v_end_collision_time, __pyx_t_2);
        __pyx_t_2 = 0;
      }

 2553:         # Now we're essentially finding the intersection between the intervals [start_collision_time, end_collision_time] and [0, infinity], and returning the start of that intersection interval

+2554:         if end_collision_time < 0.0:

    __pyx_t_2 = PyObject_RichCompare(__pyx_v_end_collision_time, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2554, __pyx_L1_error)
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2554, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_7) {
/* … */
    }

 2555:             # No overlap

+2556:             return INFINITY

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_2 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2556, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;

+2557:         elif start_collision_time <= 0.0:

    __pyx_t_2 = PyObject_RichCompare(__pyx_v_start_collision_time, __pyx_mstate_global->__pyx_float_0_0, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2557, __pyx_L1_error)
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2557, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_7) {
/* … */
    }

 2558:             # start_collision_time <= 0.0 <= end_collision_time

+2559:             return 0.0

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __pyx_r = __pyx_mstate_global->__pyx_float_0_0;
      goto __pyx_L0;

 2560:         else:

 2561:             # start_collision_time > 0.0 and 0.0 <= end_collision_time

+2562:             return start_collision_time

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_v_start_collision_time);
      __pyx_r = __pyx_v_start_collision_time;
      goto __pyx_L0;
    }
  }

 2563: 

 2564: 

+2565: def find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap(ast_pos_x: float, ast_pos_y: float, ast_vel_x: float, ast_vel_y: float, game_state: GameState) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_95find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_95find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap = {"find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_95find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_95find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_ast_pos_x;
  double __pyx_v_ast_pos_y;
  double __pyx_v_ast_vel_x;
  double __pyx_v_ast_vel_y;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ast_pos_x,&__pyx_mstate_global->__pyx_n_u_ast_pos_y,&__pyx_mstate_global->__pyx_n_u_ast_vel_x,&__pyx_mstate_global->__pyx_n_u_ast_vel_y,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2565, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2565, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2565, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2565, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2565, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2565, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap", 0) < 0) __PYX_ERR(0, 2565, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 5; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap", 1, 5, 5, i); __PYX_ERR(0, 2565, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 5)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2565, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2565, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2565, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2565, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2565, __pyx_L3_error)
    }
    __pyx_v_ast_pos_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_ast_pos_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2565, __pyx_L3_error)
    __pyx_v_ast_pos_y = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_ast_pos_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2565, __pyx_L3_error)
    __pyx_v_ast_vel_x = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ast_vel_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2565, __pyx_L3_error)
    __pyx_v_ast_vel_y = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ast_vel_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2565, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[4]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap", 1, 5, 5, __pyx_nargs); __PYX_ERR(0, 2565, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2565, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_94find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap(__pyx_self, __pyx_v_ast_pos_x, __pyx_v_ast_pos_y, __pyx_v_ast_vel_x, __pyx_v_ast_vel_y, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_94find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_ast_pos_x, double __pyx_v_ast_pos_y, double __pyx_v_ast_vel_x, double __pyx_v_ast_vel_y, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_x_interval = NULL;
  PyObject *__pyx_v_y_interval = NULL;
  PyObject *__pyx_v_start = NULL;
  PyObject *__pyx_v_end = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_x_interval);
  __Pyx_XDECREF(__pyx_v_y_interval);
  __Pyx_XDECREF(__pyx_v_start);
  __Pyx_XDECREF(__pyx_v_end);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ast_pos_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2565, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ast_pos_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2565, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ast_vel_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2565, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ast_vel_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2565, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2565, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2565, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_95find_time_interval_in_which_unwrapped_asteroid_is_within_main_wrap, 0, __pyx_mstate_global->__pyx_n_u_find_time_interval_in_which_unwr, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[120])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_find_time_interval_in_which_unwr, __pyx_t_4) < 0) __PYX_ERR(0, 2565, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2566:     #if is_close_to_zero(ast_vel_x) and is_close_to_zero(ast_vel_y) and check_coordinate_bounds(game_state, ast_pos_x, ast_pos_y):

 2567:     #    return -inf, inf

 2568:     # Do the x and y components separately

+2569:     if is_close_to_zero(ast_vel_x):

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2569, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ast_vel_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2569, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2569, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2569, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_6) {
/* … */
    goto __pyx_L3;
  }

+2570:         if check_coordinate_bounds(game_state, ast_pos_x, 0.0):

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2570, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_ast_pos_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2570, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_3, ((PyObject *)__pyx_v_game_state), __pyx_t_2, __pyx_mstate_global->__pyx_float_0_0};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2570, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2570, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_6) {
/* … */
      goto __pyx_L4;
    }

 2571:             # x coordinates are inbounds, so the asteroid will always be within the main wrap

+2572:             x_interval = -INFINITY, INFINITY

      __pyx_t_1 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2572, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2572, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2572, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_GIVEREF(__pyx_t_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2572, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2572, __pyx_L1_error);
      __pyx_t_1 = 0;
      __pyx_t_4 = 0;
      __pyx_v_x_interval = __pyx_t_2;
      __pyx_t_2 = 0;

 2573:         else:

 2574:             # x coordinates are out of bounds, so the asteroid never gets to be within the main wrap

+2575:             return NAN, NAN

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_2 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2575, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_4 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2575, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2575, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_2);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2575, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2575, __pyx_L1_error);
      __pyx_t_2 = 0;
      __pyx_t_4 = 0;
      __pyx_r = __pyx_t_1;
      __pyx_t_1 = 0;
      goto __pyx_L0;
    }
    __pyx_L4:;

 2576:     else:

 2577:         # x(t) = x_0 + t*vx

 2578:         # 0 = x_0 + t*vx, t = -x_0/vx

 2579:         # width = x_0 + t*vx, t = (width - x_0)/vx

+2580:         if ast_vel_x > 0.0:

  /*else*/ {
    __pyx_t_6 = (__pyx_v_ast_vel_x > 0.0);
    if (__pyx_t_6) {
/* … */
      goto __pyx_L5;
    }

 2581:             # Moving left to right

+2582:             x_interval = -ast_pos_x/ast_vel_x, (game_state.map_size[0] - ast_pos_x)/ast_vel_x

      __pyx_t_7 = (-__pyx_v_ast_pos_x);
      if (unlikely(__pyx_v_ast_vel_x == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2582, __pyx_L1_error)
      }
      __pyx_t_1 = PyFloat_FromDouble((__pyx_t_7 / __pyx_v_ast_vel_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ast_pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ast_vel_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2582, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2582, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_2);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 2582, __pyx_L1_error);
      __pyx_t_1 = 0;
      __pyx_t_2 = 0;
      __pyx_v_x_interval = __pyx_t_4;
      __pyx_t_4 = 0;

 2583:         else:

+2584:             x_interval = (game_state.map_size[0] - ast_pos_x)/ast_vel_x, -ast_pos_x/ast_vel_x

    /*else*/ {
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ast_pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ast_vel_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_7 = (-__pyx_v_ast_pos_x);
      if (unlikely(__pyx_v_ast_vel_x == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2584, __pyx_L1_error)
      }
      __pyx_t_4 = PyFloat_FromDouble((__pyx_t_7 / __pyx_v_ast_vel_x)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_2);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2584, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2584, __pyx_L1_error);
      __pyx_t_2 = 0;
      __pyx_t_4 = 0;
      __pyx_v_x_interval = __pyx_t_1;
      __pyx_t_1 = 0;
    }
    __pyx_L5:;
  }
  __pyx_L3:;

 2585: 

+2586:     if is_close_to_zero(ast_vel_y):

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2586, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ast_vel_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2586, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2586, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_6) {
/* … */
    goto __pyx_L6;
  }

+2587:         if check_coordinate_bounds(game_state, 0.0, ast_pos_y):

    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2587, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ast_pos_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2587, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_2, ((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_float_0_0, __pyx_t_4};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2587, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2587, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_6) {
/* … */
      goto __pyx_L7;
    }

 2588:             # y coordinates are inbounds, so the asteroid will always be within the main wrap

+2589:             y_interval = -INFINITY, INFINITY

      __pyx_t_1 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2589, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2589, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2589, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2589, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2589, __pyx_L1_error);
      __pyx_t_1 = 0;
      __pyx_t_3 = 0;
      __pyx_v_y_interval = __pyx_t_4;
      __pyx_t_4 = 0;

 2590:         else:

 2591:             # y coordinates are out of bounds, so the asteroid never gets to be within the main wrap

+2592:             return NAN, NAN

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_4 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2592, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2592, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2592, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2592, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2592, __pyx_L1_error);
      __pyx_t_4 = 0;
      __pyx_t_3 = 0;
      __pyx_r = __pyx_t_1;
      __pyx_t_1 = 0;
      goto __pyx_L0;
    }
    __pyx_L7:;

 2593:     else:

 2594:         # y(t) = y_0 + t*vy

 2595:         # 0 = y_0 + t*vy, t = -y_0/vy

 2596:         # height = y_0 + t*vy, t = (height - y_0)/vy

+2597:         if ast_vel_y > 0.0:

  /*else*/ {
    __pyx_t_6 = (__pyx_v_ast_vel_y > 0.0);
    if (__pyx_t_6) {
/* … */
      goto __pyx_L8;
    }

 2598:             # Moving up

+2599:             y_interval = -ast_pos_y/ast_vel_y, (game_state.map_size[1] - ast_pos_y)/ast_vel_y

      __pyx_t_7 = (-__pyx_v_ast_pos_y);
      if (unlikely(__pyx_v_ast_vel_y == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2599, __pyx_L1_error)
      }
      __pyx_t_1 = PyFloat_FromDouble((__pyx_t_7 / __pyx_v_ast_vel_y)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ast_pos_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ast_vel_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2599, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2599, __pyx_L1_error);
      __pyx_t_1 = 0;
      __pyx_t_4 = 0;
      __pyx_v_y_interval = __pyx_t_3;
      __pyx_t_3 = 0;

 2600:         else:

+2601:             y_interval = (game_state.map_size[1] - ast_pos_y)/ast_vel_y, -ast_pos_y/ast_vel_y

    /*else*/ {
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ast_pos_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = PyNumber_Subtract(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ast_vel_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_7 = (-__pyx_v_ast_pos_y);
      if (unlikely(__pyx_v_ast_vel_y == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2601, __pyx_L1_error)
      }
      __pyx_t_3 = PyFloat_FromDouble((__pyx_t_7 / __pyx_v_ast_vel_y)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2601, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2601, __pyx_L1_error);
      __pyx_t_4 = 0;
      __pyx_t_3 = 0;
      __pyx_v_y_interval = __pyx_t_1;
      __pyx_t_1 = 0;
    }
    __pyx_L8:;
  }
  __pyx_L6:;

 2602: 

+2603:     assert x_interval[0] <= x_interval[1]

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x_interval, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2603, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_x_interval, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2603, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2603, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2603, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_6)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 2603, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 2603, __pyx_L1_error)
  #endif

+2604:     assert y_interval[0] <= y_interval[1]

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_y_interval, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2604, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_y_interval, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2604, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2604, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2604, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_6)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 2604, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 2604, __pyx_L1_error)
  #endif

 2605: 

 2606:     # Now that we have the x and y intervals, combine them into a unified interval of time

 2607:     # Take the intersection of two intervals:

+2608:     if x_interval[1] < y_interval[0] or y_interval[1] < x_interval[0]:

  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x_interval, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_y_interval, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!__pyx_t_8) {
  } else {
    __pyx_t_6 = __pyx_t_8;
    goto __pyx_L10_bool_binop_done;
  }
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_y_interval, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_x_interval, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2608, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_6 = __pyx_t_8;
  __pyx_L10_bool_binop_done:;
  if (__pyx_t_6) {
/* … */
  }

 2609:         # One interval ends before the next one starts, so there's no overlap

+2610:         return NAN, NAN

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2610, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2610, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2610, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_1);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2610, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2610, __pyx_L1_error);
    __pyx_t_1 = 0;
    __pyx_t_3 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 2611:     else:

 2612:         # The intervals overlap!

 2613:         # The start of the intersection is the maximum of the two start times

+2614:         start = max(x_interval[0], y_interval[0])

  /*else*/ {
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_y_interval, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2614, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_x_interval, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2614, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2614, __pyx_L1_error)
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2614, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_6) {
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_1 = __pyx_t_4;
    } else {
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_1 = __pyx_t_3;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __pyx_t_1;
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_start = __pyx_t_4;
    __pyx_t_4 = 0;

 2615:         # The end of the intersection is the minimum of the two end times

+2616:         end = min(x_interval[1], y_interval[1])

    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_y_interval, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2616, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x_interval, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2616, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2616, __pyx_L1_error)
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2616, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_6) {
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_3 = __pyx_t_4;
    } else {
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_3 = __pyx_t_1;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __pyx_t_3;
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_end = __pyx_t_4;
    __pyx_t_4 = 0;

+2617:         return start, end

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2617, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_v_start);
    __Pyx_GIVEREF(__pyx_v_start);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_start) != (0)) __PYX_ERR(0, 2617, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_end);
    __Pyx_GIVEREF(__pyx_v_end);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_end) != (0)) __PYX_ERR(0, 2617, __pyx_L1_error);
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;
  }

 2618: 

 2619: 

 2620: # It helps a bit to LRU cache this... but we're doing a global asteroids cache already so it's fine

+2621: def calculate_border_crossings(pos_x: float, pos_y: float, vel_x: float, vel_y: float, width: float, height: float, time_horizon: float) -> list[tuple[int, int]]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_97calculate_border_crossings(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_97calculate_border_crossings = {"calculate_border_crossings", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_97calculate_border_crossings, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_97calculate_border_crossings(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_pos_x;
  double __pyx_v_pos_y;
  double __pyx_v_vel_x;
  double __pyx_v_vel_y;
  double __pyx_v_width;
  double __pyx_v_height;
  double __pyx_v_time_horizon;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("calculate_border_crossings (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pos_x,&__pyx_mstate_global->__pyx_n_u_pos_y,&__pyx_mstate_global->__pyx_n_u_vel_x,&__pyx_mstate_global->__pyx_n_u_vel_y,&__pyx_mstate_global->__pyx_n_u_width,&__pyx_mstate_global->__pyx_n_u_height,&__pyx_mstate_global->__pyx_n_u_time_horizon,0};
  PyObject* values[7] = {0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2621, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2621, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2621, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2621, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2621, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2621, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2621, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2621, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "calculate_border_crossings", 0) < 0) __PYX_ERR(0, 2621, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 7; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("calculate_border_crossings", 1, 7, 7, i); __PYX_ERR(0, 2621, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 7)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2621, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2621, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2621, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2621, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2621, __pyx_L3_error)
      values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2621, __pyx_L3_error)
      values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2621, __pyx_L3_error)
    }
    __pyx_v_pos_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_pos_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L3_error)
    __pyx_v_pos_y = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_pos_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L3_error)
    __pyx_v_vel_x = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vel_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L3_error)
    __pyx_v_vel_y = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_vel_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L3_error)
    __pyx_v_width = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_width == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L3_error)
    __pyx_v_height = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_height == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L3_error)
    __pyx_v_time_horizon = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_time_horizon == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("calculate_border_crossings", 1, 7, 7, __pyx_nargs); __PYX_ERR(0, 2621, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.calculate_border_crossings", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_96calculate_border_crossings(__pyx_self, __pyx_v_pos_x, __pyx_v_pos_y, __pyx_v_vel_x, __pyx_v_vel_y, __pyx_v_width, __pyx_v_height, __pyx_v_time_horizon);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_96calculate_border_crossings(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_pos_x, double __pyx_v_pos_y, double __pyx_v_vel_x, double __pyx_v_vel_y, double __pyx_v_width, double __pyx_v_height, double __pyx_v_time_horizon) {
  PyObject *__pyx_v_x_crossings_times = NULL;
  PyObject *__pyx_v_y_crossings_times = NULL;
  PyObject *__pyx_v_x_crossings = NULL;
  PyObject *__pyx_v_y_crossings = NULL;
  double __pyx_v_abs_vx;
  double __pyx_v_x_crossing_interval;
  double __pyx_v_time_to_first_x_crossing;
  double __pyx_v_abs_vy;
  double __pyx_v_y_crossing_interval;
  double __pyx_v_time_to_first_y_crossing;
  PyObject *__pyx_v_border_crossing_sequence = 0;
  PyObject *__pyx_v_i = NULL;
  PyObject *__pyx_v_j = NULL;
  PyObject *__pyx_v_current_universe_x = 0;
  PyObject *__pyx_v_current_universe_y = 0;
  PyObject *__pyx_v_universe_increment_direction_x = 0;
  PyObject *__pyx_v_universe_increment_direction_y = 0;
  PyObject *__pyx_v_universes = NULL;
  PyObject *__pyx_v_crossing = NULL;
  PyObject *__pyx_v_next_time = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.calculate_border_crossings", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_x_crossings_times);
  __Pyx_XDECREF(__pyx_v_y_crossings_times);
  __Pyx_XDECREF(__pyx_v_x_crossings);
  __Pyx_XDECREF(__pyx_v_y_crossings);
  __Pyx_XDECREF(__pyx_v_border_crossing_sequence);
  __Pyx_XDECREF(__pyx_v_i);
  __Pyx_XDECREF(__pyx_v_j);
  __Pyx_XDECREF(__pyx_v_current_universe_x);
  __Pyx_XDECREF(__pyx_v_current_universe_y);
  __Pyx_XDECREF(__pyx_v_universe_increment_direction_x);
  __Pyx_XDECREF(__pyx_v_universe_increment_direction_y);
  __Pyx_XDECREF(__pyx_v_universes);
  __Pyx_XDECREF(__pyx_v_crossing);
  __Pyx_XDECREF(__pyx_v_next_time);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pos_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pos_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vel_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vel_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_width, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_height, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_time_horizon, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_tuple_int_int) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_97calculate_border_crossings, 0, __pyx_mstate_global->__pyx_n_u_calculate_border_crossings, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[121])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2621, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_calculate_border_crossings, __pyx_t_2) < 0) __PYX_ERR(0, 2621, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2622:     # Initialize lists to hold crossing times

+2623:     x_crossings_times = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2623, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_x_crossings_times = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2624:     y_crossings_times = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_y_crossings_times = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2625:     x_crossings = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_x_crossings = __pyx_mstate_global->__pyx_int_0;

+2626:     y_crossings = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_y_crossings = __pyx_mstate_global->__pyx_int_0;

 2627: 

 2628:     # Calculate crossing times for x (if vx is not zero to avoid division by zero)

+2629:     abs_vx = abs(vel_x)

  __pyx_t_2 = fabs(__pyx_v_vel_x); 
  __pyx_v_abs_vx = __pyx_t_2;

+2630:     if abs_vx > EPS:

  __pyx_t_3 = (__pyx_v_abs_vx > __pyx_v_14neo_controller_EPS);
  if (__pyx_t_3) {
/* … */
  }

 2631:         # Calculate time to first x-boundary crossing based on direction of vx

+2632:         x_crossing_interval = width/abs_vx

    if (unlikely(__pyx_v_abs_vx == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 2632, __pyx_L1_error)
    }
    __pyx_v_x_crossing_interval = (__pyx_v_width / __pyx_v_abs_vx);

 2633:         # print(f"x_crossing_interval: {x_crossing_interval}")

+2634:         time_to_first_x_crossing = ((width - pos_x)/vel_x if vel_x > 0.0 else -pos_x/vel_x)

    __pyx_t_3 = (__pyx_v_vel_x > 0.0);
    if (__pyx_t_3) {
      __pyx_t_4 = (__pyx_v_width - __pyx_v_pos_x);
      if (unlikely(__pyx_v_vel_x == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2634, __pyx_L1_error)
      }
      __pyx_t_2 = (__pyx_t_4 / __pyx_v_vel_x);
    } else {
      __pyx_t_4 = (-__pyx_v_pos_x);
      if (unlikely(__pyx_v_vel_x == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2634, __pyx_L1_error)
      }
      __pyx_t_2 = (__pyx_t_4 / __pyx_v_vel_x);
    }
    __pyx_v_time_to_first_x_crossing = __pyx_t_2;

+2635:         x_crossings_times.append(time_to_first_x_crossing)

    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_time_to_first_x_crossing); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2635, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_x_crossings_times, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2635, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2636:         x_crossings += 1

    __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_v_x_crossings, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2636, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF_SET(__pyx_v_x_crossings, __pyx_t_1);
    __pyx_t_1 = 0;

 2637:         # Add additional crossings until time c is reached

+2638:         while (next_time := x_crossings_times[-1] + x_crossing_interval) <= time_horizon:

    while (1) {
      __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_x_crossings_times, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2638, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = PyFloat_FromDouble(__pyx_v_x_crossing_interval); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2638, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_7 = PyNumber_Add(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2638, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF_SET(__pyx_v_next_time, __pyx_t_7);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_6 = PyFloat_FromDouble(__pyx_v_time_horizon); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2638, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2638, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 2638, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (!__pyx_t_3) break;

+2639:             x_crossings_times.append(next_time)

      __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_x_crossings_times, __pyx_v_next_time); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2639, __pyx_L1_error)

+2640:             x_crossings += 1

      __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_v_x_crossings, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2640, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF_SET(__pyx_v_x_crossings, __pyx_t_1);
      __pyx_t_1 = 0;
    }

 2641:     # print(f"x crossing times: {x_crossings_times}")

 2642:     # Calculate crossing times for y (if vy is not zero)

+2643:     abs_vy = abs(vel_y)

  __pyx_t_2 = fabs(__pyx_v_vel_y); 
  __pyx_v_abs_vy = __pyx_t_2;

+2644:     if abs_vy > EPS:

  __pyx_t_3 = (__pyx_v_abs_vy > __pyx_v_14neo_controller_EPS);
  if (__pyx_t_3) {
/* … */
  }

 2645:         # Calculate time to first y-boundary crossing based on direction of vy

+2646:         y_crossing_interval = height/abs_vy

    if (unlikely(__pyx_v_abs_vy == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 2646, __pyx_L1_error)
    }
    __pyx_v_y_crossing_interval = (__pyx_v_height / __pyx_v_abs_vy);

 2647:         # print(f"y_crossing_interval: {y_crossing_interval}")

+2648:         time_to_first_y_crossing = ((height - pos_y)/vel_y if vel_y > 0.0 else -pos_y/vel_y)

    __pyx_t_3 = (__pyx_v_vel_y > 0.0);
    if (__pyx_t_3) {
      __pyx_t_4 = (__pyx_v_height - __pyx_v_pos_y);
      if (unlikely(__pyx_v_vel_y == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2648, __pyx_L1_error)
      }
      __pyx_t_2 = (__pyx_t_4 / __pyx_v_vel_y);
    } else {
      __pyx_t_4 = (-__pyx_v_pos_y);
      if (unlikely(__pyx_v_vel_y == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2648, __pyx_L1_error)
      }
      __pyx_t_2 = (__pyx_t_4 / __pyx_v_vel_y);
    }
    __pyx_v_time_to_first_y_crossing = __pyx_t_2;

+2649:         y_crossings_times.append(time_to_first_y_crossing)

    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_time_to_first_y_crossing); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2649, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_y_crossings_times, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2649, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2650:         y_crossings += 1

    __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_v_y_crossings, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2650, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF_SET(__pyx_v_y_crossings, __pyx_t_1);
    __pyx_t_1 = 0;

 2651:         # Add additional crossings until time c is reached

+2652:         while (next_time := y_crossings_times[-1] + y_crossing_interval) <= time_horizon:

    while (1) {
      __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_y_crossings_times, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2652, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = PyFloat_FromDouble(__pyx_v_y_crossing_interval); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2652, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_7 = PyNumber_Add(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2652, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF_SET(__pyx_v_next_time, __pyx_t_7);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_6 = PyFloat_FromDouble(__pyx_v_time_horizon); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2652, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2652, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 2652, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (!__pyx_t_3) break;

+2653:             y_crossings_times.append(next_time)

      __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_y_crossings_times, __pyx_v_next_time); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2653, __pyx_L1_error)

+2654:             y_crossings += 1

      __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_v_y_crossings, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2654, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF_SET(__pyx_v_y_crossings, __pyx_t_1);
      __pyx_t_1 = 0;
    }

 2655:     # print(f"y crossing times: {y_crossings_times}")

 2656:     # Merge the two lists while tracking the origin of each time

 2657:     #merged_times = []

+2658:     border_crossing_sequence: list[bool] = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2658, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_border_crossing_sequence = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2659:     i = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_i = __pyx_mstate_global->__pyx_int_0;

+2660:     j = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_j = __pyx_mstate_global->__pyx_int_0;

 2661: 

 2662:     # True is for x, False is for y

+2663:     while i < x_crossings and j < y_crossings:

  while (1) {
    __pyx_t_1 = PyObject_RichCompare(__pyx_v_i, __pyx_v_x_crossings, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2663, __pyx_L1_error)
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2663, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_8) {
    } else {
      __pyx_t_3 = __pyx_t_8;
      goto __pyx_L11_bool_binop_done;
    }
    __pyx_t_1 = PyObject_RichCompare(__pyx_v_j, __pyx_v_y_crossings, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2663, __pyx_L1_error)
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2663, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_3 = __pyx_t_8;
    __pyx_L11_bool_binop_done:;
    if (!__pyx_t_3) break;

+2664:         if x_crossings_times[i] < y_crossings_times[j]:

    __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_x_crossings_times, __pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2664, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_y_crossings_times, __pyx_v_j); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2664, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_1, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2664, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 2664, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_3) {
/* … */
      goto __pyx_L13;
    }

 2665:             #merged_times.append(x_crossings_times[i])

+2666:             border_crossing_sequence.append(True)

      __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_border_crossing_sequence, Py_True); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2666, __pyx_L1_error)

+2667:             i += 1

      __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_v_i, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_7);
      __pyx_t_7 = 0;

 2668:         else:

 2669:             #merged_times.append(y_crossings_times[j])

+2670:             border_crossing_sequence.append(False)

    /*else*/ {
      __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_border_crossing_sequence, Py_False); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2670, __pyx_L1_error)

+2671:             j += 1

      __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_v_j, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2671, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF_SET(__pyx_v_j, __pyx_t_7);
      __pyx_t_7 = 0;
    }
    __pyx_L13:;
  }

 2672: 

 2673:     # Add any remaining times from the x_crossings_times list

+2674:     while i < x_crossings:

  while (1) {
    __pyx_t_7 = PyObject_RichCompare(__pyx_v_i, __pyx_v_x_crossings, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2674, __pyx_L1_error)
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 2674, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (!__pyx_t_3) break;

 2675:         #merged_times.append(x_crossings_times[i])

+2676:         border_crossing_sequence.append(True)

    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_border_crossing_sequence, Py_True); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2676, __pyx_L1_error)

+2677:         i += 1

    __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_v_i, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2677, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_7);
    __pyx_t_7 = 0;
  }

 2678: 

 2679:     # Add any remaining times from the y_crossings_times list

+2680:     while j < y_crossings:

  while (1) {
    __pyx_t_7 = PyObject_RichCompare(__pyx_v_j, __pyx_v_y_crossings, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2680, __pyx_L1_error)
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 2680, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (!__pyx_t_3) break;

 2681:         #merged_times.append(y_crossings_times[j])

+2682:         border_crossing_sequence.append(False)

    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_border_crossing_sequence, Py_False); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2682, __pyx_L1_error)

+2683:         j += 1

    __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_v_j, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2683, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF_SET(__pyx_v_j, __pyx_t_7);
    __pyx_t_7 = 0;
  }

 2684: 

 2685:     # Initialize current universe coordinates and list of visited universes

+2686:     current_universe_x: int = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_current_universe_x = __pyx_mstate_global->__pyx_int_0;

+2687:     current_universe_y: int = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_current_universe_y = __pyx_mstate_global->__pyx_int_0;

+2688:     universe_increment_direction_x: int = 1 if vel_x > 0.0 else -1

  __pyx_t_3 = (__pyx_v_vel_x > 0.0);
  if (__pyx_t_3) {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
    __pyx_t_7 = __pyx_mstate_global->__pyx_int_1;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
    __pyx_t_7 = __pyx_mstate_global->__pyx_int_neg_1;
  }
  __pyx_v_universe_increment_direction_x = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;

+2689:     universe_increment_direction_y: int = 1 if vel_y > 0.0 else -1

  __pyx_t_3 = (__pyx_v_vel_y > 0.0);
  if (__pyx_t_3) {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
    __pyx_t_7 = __pyx_mstate_global->__pyx_int_1;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
    __pyx_t_7 = __pyx_mstate_global->__pyx_int_neg_1;
  }
  __pyx_v_universe_increment_direction_y = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;

 2690: 

 2691:     # Iterate through merged crossing times and sequence

 2692:     #universes = [(current_universe_x, current_universe_y)]

+2693:     universes = []

  __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2693, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_v_universes = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;

+2694:     for crossing in border_crossing_sequence:

  __pyx_t_7 = __pyx_v_border_crossing_sequence; __Pyx_INCREF(__pyx_t_7);
  __pyx_t_9 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2694, __pyx_L1_error)
      #endif
      if (__pyx_t_9 >= __pyx_temp) break;
    }
    __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_9);
    ++__pyx_t_9;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2694, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_XDECREF_SET(__pyx_v_crossing, __pyx_t_6);
    __pyx_t_6 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+2695:         if crossing: # Crossing is for x

    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_crossing); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 2695, __pyx_L1_error)
    if (__pyx_t_3) {
/* … */
      goto __pyx_L20;
    }

+2696:             current_universe_x += universe_increment_direction_x

      __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_v_current_universe_x, __pyx_v_universe_increment_direction_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2696, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF_SET(__pyx_v_current_universe_x, ((PyObject*)__pyx_t_6));
      __pyx_t_6 = 0;

 2697:         else:  # crossing is for y

+2698:             current_universe_y += universe_increment_direction_y

    /*else*/ {
      __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_v_current_universe_y, __pyx_v_universe_increment_direction_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2698, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF_SET(__pyx_v_current_universe_y, ((PyObject*)__pyx_t_6));
      __pyx_t_6 = 0;
    }
    __pyx_L20:;

+2699:         universes.append((current_universe_x, current_universe_y))

    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2699, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_v_current_universe_x);
    __Pyx_GIVEREF(__pyx_v_current_universe_x);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_current_universe_x) != (0)) __PYX_ERR(0, 2699, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_current_universe_y);
    __Pyx_GIVEREF(__pyx_v_current_universe_y);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_current_universe_y) != (0)) __PYX_ERR(0, 2699, __pyx_L1_error);
    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_universes, __pyx_t_6); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 2699, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+2700:     return universes

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_universes);
  __pyx_r = __pyx_v_universes;
  goto __pyx_L0;

 2701: 

 2702: 

+2703: def unwrap_asteroid(asteroid: Asteroid, max_x: float, max_y: float, time_horizon_s: float = 10.0, use_cache: bool = True) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_99unwrap_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_99unwrap_asteroid = {"unwrap_asteroid", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_99unwrap_asteroid, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_99unwrap_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  double __pyx_v_max_x;
  double __pyx_v_max_y;
  double __pyx_v_time_horizon_s;
  PyObject *__pyx_v_use_cache = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("unwrap_asteroid (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_max_x,&__pyx_mstate_global->__pyx_n_u_max_y,&__pyx_mstate_global->__pyx_n_u_time_horizon_s,&__pyx_mstate_global->__pyx_n_u_use_cache,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2703, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2703, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2703, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2703, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2703, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2703, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "unwrap_asteroid", 0) < 0) __PYX_ERR(0, 2703, __pyx_L3_error)
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True)));
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("unwrap_asteroid", 0, 3, 5, i); __PYX_ERR(0, 2703, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2703, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2703, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2703, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2703, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2703, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True)));
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_max_x = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_max_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2703, __pyx_L3_error)
    __pyx_v_max_y = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_max_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2703, __pyx_L3_error)
    if (values[3]) {
      __pyx_v_time_horizon_s = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_time_horizon_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2703, __pyx_L3_error)
    } else {
      __pyx_v_time_horizon_s = ((double)((double)10.0));
    }
    __pyx_v_use_cache = values[4];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("unwrap_asteroid", 0, 3, 5, __pyx_nargs); __PYX_ERR(0, 2703, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.unwrap_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 2703, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_98unwrap_asteroid(__pyx_self, __pyx_v_asteroid, __pyx_v_max_x, __pyx_v_max_y, __pyx_v_time_horizon_s, __pyx_v_use_cache);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_98unwrap_asteroid(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, double __pyx_v_max_x, double __pyx_v_max_y, double __pyx_v_time_horizon_s, PyObject *__pyx_v_use_cache) {
  PyObject *__pyx_v_ast_hash = NULL;
  PyObject *__pyx_v_unwrapped_asteroids = 0;
  PyObject *__pyx_v_universe = NULL;
  double __pyx_v_dx;
  double __pyx_v_dy;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_AddTraceback("neo_controller.unwrap_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ast_hash);
  __Pyx_XDECREF(__pyx_v_unwrapped_asteroids);
  __Pyx_XDECREF(__pyx_v_universe);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = PyFloat_FromDouble(((double)10.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2703, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyTuple_Pack(2, __pyx_t_2, ((PyObject*)Py_True)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2703, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2703, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 2703, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_max_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2703, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_max_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2703, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time_horizon_s, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2703, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_use_cache, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 2703, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2703, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_99unwrap_asteroid, 0, __pyx_mstate_global->__pyx_n_u_unwrap_asteroid, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[122])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2703, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_unwrap_asteroid, __pyx_t_9) < 0) __PYX_ERR(0, 2703, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 2704:     #start_time = time.perf_counter()

 2705:     #global unwrap_total_time

 2706:     #time_horizon_s = UNWRAP_ASTEROID_COLLISION_FORECAST_TIME_HORIZON

 2707:     #use_cache = UNWRAP_ASTEROID_TARGET_SELECTION_TIME_HORIZON == time_horizon_s

 2708:     #hash_tuple = (asteroid.position[0], asteroid.position[1], asteroid.velocity[0], asteroid.velocity[1], time_horizon_s)

+2709:     if use_cache:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_use_cache); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2709, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+2710:         ast_hash = asteroid.int_hash()

    __pyx_t_3 = ((PyObject *)__pyx_v_asteroid);
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_4 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_int_hash, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2710, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_v_ast_hash = __pyx_t_2;
    __pyx_t_2 = 0;

 2711:         global unwrap_cache

+2712:         if ast_hash in unwrap_cache:

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_unwrap_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2712, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_ast_hash, __pyx_t_2, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2712, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_1) {
/* … */
    }

 2713:             #print("CACHE HIT")

 2714:             #global unwrap_cache_hits

 2715:             #unwrap_cache_hits += 1

 2716:             #unwrap_total_time += time.perf_counter() - start_time

+2717:             return unwrap_cache[ast_hash]

      __Pyx_XDECREF(__pyx_r);
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_unwrap_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2717, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_ast_hash); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2717, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_3))) __PYX_ERR(0, 2717, __pyx_L1_error)
      __pyx_r = ((PyObject*)__pyx_t_3);
      __pyx_t_3 = 0;
      goto __pyx_L0;

 2718:     #print("CACHE MISS")

 2719:     #global unwrap_cache_misses

 2720:     #unwrap_cache_misses += 1

+2721:     unwrapped_asteroids: list[Asteroid] = [asteroid.copy()]

  __pyx_t_2 = ((PyObject *)__pyx_v_asteroid);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2721, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2721, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 2721, __pyx_L1_error);
  __pyx_t_3 = 0;
  __pyx_v_unwrapped_asteroids = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+2722:     if abs(asteroid.velocity[0]) < EPS and abs(asteroid.velocity[1]) < EPS:

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_6) {
  } else {
    __pyx_t_1 = __pyx_t_6;
    goto __pyx_L6_bool_binop_done;
  }
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyObject_RichCompare(__pyx_t_5, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2722, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_1 = __pyx_t_6;
  __pyx_L6_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 2723:         # An asteroid that is stationary will never move across borders

+2724:         if use_cache:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_use_cache); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2724, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+2725:             unwrap_cache[ast_hash] = unwrapped_asteroids

      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_unwrap_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2725, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      if (unlikely(!__pyx_v_ast_hash)) { __Pyx_RaiseUnboundLocalError("ast_hash"); __PYX_ERR(0, 2725, __pyx_L1_error) }
      if (unlikely((PyObject_SetItem(__pyx_t_2, __pyx_v_ast_hash, __pyx_v_unwrapped_asteroids) < 0))) __PYX_ERR(0, 2725, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2726:         #unwrap_total_time += time.perf_counter() - start_time

+2727:         return unwrapped_asteroids

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_unwrapped_asteroids);
    __pyx_r = __pyx_v_unwrapped_asteroids;
    goto __pyx_L0;

 2728: 

 2729:     # The idea is to track which universes the asteroid visits from t=t_0 until t=t_0 + time_horizon_s.

 2730:     # The current universe is (0, 0) and if the asteroid wraps to the right, it visits (1, 0). If it wraps down, it visits (0, -1). If it wraps right and then down, it starts in (0, 0), visits (1, 0), and finally (1, -1).

 2731:     #border_crossings = calculate_border_crossings(asteroid.position[0], asteroid.position[1], asteroid.velocity[0], asteroid.velocity[1], max_x, max_y, time_horizon_s)

+2732:     for universe in calculate_border_crossings(asteroid.position[0], asteroid.position[1], asteroid.velocity[0], asteroid.velocity[1], max_x, max_y, time_horizon_s):

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_calculate_border_crossings); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_max_x); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_12 = PyFloat_FromDouble(__pyx_v_max_y); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_13 = PyFloat_FromDouble(__pyx_v_time_horizon_s); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[8] = {__pyx_t_3, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_7, __pyx_t_12, __pyx_t_13};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_4, (8-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2732, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_5 = __pyx_t_2; __Pyx_INCREF(__pyx_t_5);
    __pyx_t_14 = 0;
    __pyx_t_15 = NULL;
  } else {
    __pyx_t_14 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2732, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2732, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_15)) {
      if (likely(PyList_CheckExact(__pyx_t_5))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2732, __pyx_L1_error)
          #endif
          if (__pyx_t_14 >= __pyx_temp) break;
        }
        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_14);
        ++__pyx_t_14;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2732, __pyx_L1_error)
          #endif
          if (__pyx_t_14 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_14));
        #else
        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_14);
        #endif
        ++__pyx_t_14;
      }
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2732, __pyx_L1_error)
    } else {
      __pyx_t_2 = __pyx_t_15(__pyx_t_5);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2732, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_universe, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 2733:         # We negate the directions because we're using the frame of reference of the ship now, not the asteroid

+2734:         dx = -float(universe[0])*max_x

    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_universe, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2734, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_16 = __Pyx_PyObject_AsDouble(__pyx_t_2); if (unlikely(__pyx_t_16 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2734, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_dx = ((-__pyx_t_16) * __pyx_v_max_x);

+2735:         dy = -float(universe[1])*max_y

    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_universe, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2735, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_16 = __Pyx_PyObject_AsDouble(__pyx_t_2); if (unlikely(__pyx_t_16 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_dy = ((-__pyx_t_16) * __pyx_v_max_y);

 2736:         #unwrapped_asteroid: Asteroid = asteroid.copy()

 2737:         #unwrapped_asteroid.position = (unwrapped_asteroid.position[0] + dx, unwrapped_asteroid.position[1] + dy)

 2738:         #unwrapped_asteroids.append(unwrapped_asteroid)

+2739:         unwrapped_asteroids.append(Asteroid(

    __pyx_t_13 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
    __pyx_t_12 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 
/* … */
    __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_unwrapped_asteroids, ((PyObject *)__pyx_t_2)); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 2739, __pyx_L1_error)
    __Pyx_DECREF((PyObject *)__pyx_t_2); __pyx_t_2 = 0;

+2740:             position=(asteroid.position[0] + dx, asteroid.position[1] + dy),

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_dx); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_10 = PyNumber_Add(__pyx_t_11, __pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_dy); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = PyNumber_Add(__pyx_t_11, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_GIVEREF(__pyx_t_10);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_10) != (0)) __PYX_ERR(0, 2740, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_9);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 2740, __pyx_L1_error);
    __pyx_t_10 = 0;
    __pyx_t_9 = 0;

+2741:             velocity=asteroid.velocity,

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2741, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);

+2742:             size=asteroid.size,

    __pyx_t_10 = __Pyx_PyLong_From_int(__pyx_v_asteroid->size); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2742, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);

+2743:             mass=asteroid.mass,

    __pyx_t_11 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);

+2744:             radius=asteroid.radius,

    __pyx_t_8 = PyFloat_FromDouble(__pyx_v_asteroid->radius); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);

+2745:             timesteps_until_appearance=asteroid.timesteps_until_appearance

    __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_asteroid->timesteps_until_appearance); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_13, NULL};
      __pyx_t_17 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2739, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_7, __pyx_t_17, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2739, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_9, __pyx_t_17, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 2739, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_10, __pyx_t_17, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 2739, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_11, __pyx_t_17, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 2739, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_t_8, __pyx_t_17, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 2739, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_t_3, __pyx_t_17, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 2739, __pyx_L1_error)
      __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_12, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_17);
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2739, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_2);
    }

 2746:         ))

 2747:         #yield unwrapped_asteroid

 2748:     # print(f"Returning unwrapped asteroids: {unwrapped_asteroids}")

+2749:     if use_cache:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_use_cache); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2749, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+2750:         unwrap_cache[ast_hash] = unwrapped_asteroids

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_unwrap_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (unlikely(!__pyx_v_ast_hash)) { __Pyx_RaiseUnboundLocalError("ast_hash"); __PYX_ERR(0, 2750, __pyx_L1_error) }
    if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_v_ast_hash, __pyx_v_unwrapped_asteroids) < 0))) __PYX_ERR(0, 2750, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 2751:     #unwrap_total_time += time.perf_counter() - start_time

+2752:     return unwrapped_asteroids

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_unwrapped_asteroids);
  __pyx_r = __pyx_v_unwrapped_asteroids;
  goto __pyx_L0;

 2753: 

 2754: 

+2755: def check_coordinate_bounds(game_state: GameState, x: float, y: float) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_101check_coordinate_bounds(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_101check_coordinate_bounds = {"check_coordinate_bounds", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_101check_coordinate_bounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_101check_coordinate_bounds(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  double __pyx_v_x;
  double __pyx_v_y;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("check_coordinate_bounds (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_y,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2755, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2755, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2755, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2755, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "check_coordinate_bounds", 0) < 0) __PYX_ERR(0, 2755, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("check_coordinate_bounds", 1, 3, 3, i); __PYX_ERR(0, 2755, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2755, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2755, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2755, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2755, __pyx_L3_error)
    __pyx_v_y = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2755, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("check_coordinate_bounds", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2755, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.check_coordinate_bounds", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2755, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_100check_coordinate_bounds(__pyx_self, __pyx_v_game_state, __pyx_v_x, __pyx_v_y);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_100check_coordinate_bounds(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, double __pyx_v_x, double __pyx_v_y) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.check_coordinate_bounds", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2755, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2755, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2755, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 2755, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_101check_coordinate_bounds, 0, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[123])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds, __pyx_t_2) < 0) __PYX_ERR(0, 2755, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+2756:     if 0.0 <= x <= game_state.map_size[0] and 0.0 <= y <= game_state.map_size[1]:

  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2756, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2756, __pyx_L1_error)
  if (__Pyx_PyObject_IsTrue(__pyx_t_3)) {
    __Pyx_DECREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2756, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2756, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2756, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2756, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_6) {
  } else {
    __pyx_t_1 = __pyx_t_6;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2756, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2756, __pyx_L1_error)
  if (__Pyx_PyObject_IsTrue(__pyx_t_2)) {
    __Pyx_DECREF(__pyx_t_2);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2756, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2756, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2756, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2756, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_1 = __pyx_t_6;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+2757:         return True

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;

 2758:     else:

+2759:         return False

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;
  }

 2760: 

 2761: 

+2762: def check_coordinate_bounds_exact(game_state: GameState, x: float, y: float) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_103check_coordinate_bounds_exact(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_103check_coordinate_bounds_exact = {"check_coordinate_bounds_exact", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_103check_coordinate_bounds_exact, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_103check_coordinate_bounds_exact(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  double __pyx_v_x;
  double __pyx_v_y;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("check_coordinate_bounds_exact (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_y,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2762, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2762, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2762, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2762, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "check_coordinate_bounds_exact", 0) < 0) __PYX_ERR(0, 2762, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("check_coordinate_bounds_exact", 1, 3, 3, i); __PYX_ERR(0, 2762, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2762, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2762, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2762, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
    __pyx_v_x = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2762, __pyx_L3_error)
    __pyx_v_y = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2762, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("check_coordinate_bounds_exact", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2762, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.check_coordinate_bounds_exact", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2762, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_102check_coordinate_bounds_exact(__pyx_self, __pyx_v_game_state, __pyx_v_x, __pyx_v_y);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_102check_coordinate_bounds_exact(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, double __pyx_v_x, double __pyx_v_y) {
  PyObject *__pyx_v_x_wrapped = NULL;
  PyObject *__pyx_v_y_wrapped = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.check_coordinate_bounds_exact", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_x_wrapped);
  __Pyx_XDECREF(__pyx_v_y_wrapped);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2762, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2762, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2762, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 2762, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_103check_coordinate_bounds_exact, 0, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds_exact, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds_exact, __pyx_t_9) < 0) __PYX_ERR(0, 2762, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+2763:     x_wrapped = x % game_state.map_size[0]

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Remainder(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_x_wrapped = __pyx_t_2;
  __pyx_t_2 = 0;

+2764:     y_wrapped = y % game_state.map_size[1]

  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Remainder(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_y_wrapped = __pyx_t_3;
  __pyx_t_3 = 0;

 2765:     # TODO: Maybe optimize?

+2766:     if is_close(x, x_wrapped) and is_close(y, y_wrapped):

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_v_x_wrapped};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2766, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2766, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_7) {
  } else {
    __pyx_t_4 = __pyx_t_7;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_y_wrapped};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2766, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 2766, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = __pyx_t_7;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_4) {
/* … */
  }

+2767:         return True

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;

 2768:     else:

+2769:         return False

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;
  }

 2770: 

 2771: 

+2772: def solve_quadratic(a: float, b: float, c: float) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_105solve_quadratic(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_105solve_quadratic = {"solve_quadratic", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_105solve_quadratic, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_105solve_quadratic(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_a;
  double __pyx_v_b;
  double __pyx_v_c;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solve_quadratic (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_b,&__pyx_mstate_global->__pyx_n_u_c,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2772, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2772, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2772, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2772, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "solve_quadratic", 0) < 0) __PYX_ERR(0, 2772, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("solve_quadratic", 1, 3, 3, i); __PYX_ERR(0, 2772, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2772, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2772, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2772, __pyx_L3_error)
    }
    __pyx_v_a = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_a == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2772, __pyx_L3_error)
    __pyx_v_b = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_b == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2772, __pyx_L3_error)
    __pyx_v_c = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_c == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2772, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("solve_quadratic", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2772, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_quadratic", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_104solve_quadratic(__pyx_self, __pyx_v_a, __pyx_v_b, __pyx_v_c);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_104solve_quadratic(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_a, double __pyx_v_b, double __pyx_v_c) {
  double __pyx_v_x;
  double __pyx_v_discriminant;
  double __pyx_v_q;
  double __pyx_v_x1;
  double __pyx_v_x2;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.solve_quadratic", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_a, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2772, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_b, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2772, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_c, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2772, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2772, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_105solve_quadratic, 0, __pyx_mstate_global->__pyx_n_u_solve_quadratic, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[125])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_solve_quadratic, __pyx_t_2) < 0) __PYX_ERR(0, 2772, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2773:     # This solves a*x*x + b*x + c = 0 for x

 2774:     # This handles the case where a, b, or c are 0.

 2775:     # This DOES NOT handle float overflow!

+2776:     if a == 0.0:

  __pyx_t_1 = (__pyx_v_a == 0.0);
  if (__pyx_t_1) {
/* … */
  }

 2777:         # Linear case: bx + c = 0

+2778:         if b == 0.0:

    __pyx_t_1 = (__pyx_v_b == 0.0);
    if (__pyx_t_1) {
/* … */
    }

+2779:             if c == 0.0:

      __pyx_t_1 = (__pyx_v_c == 0.0);
      if (__pyx_t_1) {
/* … */
      }

+2780:                 return 0.0, 0.0

        __Pyx_XDECREF(__pyx_r);
        __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[0]);
        __pyx_r = __pyx_mstate_global->__pyx_tuple[0];
        goto __pyx_L0;

 2781:             else:

+2782:                 return NAN, NAN

      /*else*/ {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_2 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2782, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2782, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2782, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_2);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2782, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_3);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2782, __pyx_L1_error);
        __pyx_t_2 = 0;
        __pyx_t_3 = 0;
        __pyx_r = __pyx_t_4;
        __pyx_t_4 = 0;
        goto __pyx_L0;
      }

 2783:         else:

 2784:             # One solution for the linear equation

+2785:             x = -c/b

    /*else*/ {
      __pyx_t_5 = (-__pyx_v_c);
      if (unlikely(__pyx_v_b == 0)) {
        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
        __PYX_ERR(0, 2785, __pyx_L1_error)
      }
      __pyx_v_x = (__pyx_t_5 / __pyx_v_b);

+2786:             return x, x

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2786, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2786, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2786, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2786, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2786, __pyx_L1_error);
      __pyx_t_4 = 0;
      __pyx_t_3 = 0;
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;
    }

 2787: 

+2788:     discriminant = b*b - 4.0*a*c

  __pyx_v_discriminant = ((__pyx_v_b * __pyx_v_b) - ((4.0 * __pyx_v_a) * __pyx_v_c));

+2789:     if discriminant < 0.0:

  __pyx_t_1 = (__pyx_v_discriminant < 0.0);
  if (__pyx_t_1) {
/* … */
  }

 2790:         # No real solutions

+2791:         return NAN, NAN

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2791, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2791, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2791, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_2);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2791, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2791, __pyx_L1_error);
    __pyx_t_2 = 0;
    __pyx_t_3 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 2792: 

+2793:     q = -0.5*(b + copysign(sqrt(discriminant), b))

  __pyx_v_q = (-0.5 * (__pyx_v_b + copysign(sqrt(__pyx_v_discriminant), __pyx_v_b)));

+2794:     if c == 0.0:

  __pyx_t_1 = (__pyx_v_c == 0.0);
  if (__pyx_t_1) {
/* … */
  }

+2795:         x1 = -b/a

    __pyx_t_5 = (-__pyx_v_b);
    if (unlikely(__pyx_v_a == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 2795, __pyx_L1_error)
    }
    __pyx_v_x1 = (__pyx_t_5 / __pyx_v_a);

+2796:         if x1 < 0.0:

    __pyx_t_1 = (__pyx_v_x1 < 0.0);
    if (__pyx_t_1) {
/* … */
    }

+2797:             return x1, 0.0

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2797, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2797, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2797, __pyx_L1_error);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_0_0);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_float_0_0) != (0)) __PYX_ERR(0, 2797, __pyx_L1_error);
      __pyx_t_4 = 0;
      __pyx_r = __pyx_t_3;
      __pyx_t_3 = 0;
      goto __pyx_L0;

 2798:         else:

+2799:             return 0.0, x1

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_x1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2799, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2799, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_0_0);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_float_0_0) != (0)) __PYX_ERR(0, 2799, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2799, __pyx_L1_error);
      __pyx_t_3 = 0;
      __pyx_r = __pyx_t_4;
      __pyx_t_4 = 0;
      goto __pyx_L0;
    }

 2800:     # q cannot be 0 here

+2801:     x1 = q/a

  if (unlikely(__pyx_v_a == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 2801, __pyx_L1_error)
  }
  __pyx_v_x1 = (__pyx_v_q / __pyx_v_a);

+2802:     x2 = c/q

  if (unlikely(__pyx_v_q == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 2802, __pyx_L1_error)
  }
  __pyx_v_x2 = (__pyx_v_c / __pyx_v_q);

+2803:     if x1 <= x2:

  __pyx_t_1 = (__pyx_v_x1 <= __pyx_v_x2);
  if (__pyx_t_1) {
/* … */
  }

+2804:         return x1, x2

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_x2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_GIVEREF(__pyx_t_4);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2804, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2804, __pyx_L1_error);
    __pyx_t_4 = 0;
    __pyx_t_3 = 0;
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

 2805:     else:

+2806:         return x2, x1

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_x2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2806, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_x1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2806, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2806, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_2);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 2806, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2806, __pyx_L1_error);
    __pyx_t_2 = 0;
    __pyx_t_3 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;
  }

 2807: 

 2808: 

+2809: def calculate_interception(ship_pos_x: float, ship_pos_y: float, asteroid_pos_x: float, asteroid_pos_y: float, asteroid_vel_x: float, asteroid_vel_y: float, asteroid_r: float, ship_heading_deg: float, game_state: GameState, future_shooting_timesteps: int = 0) -> tuple[bool, float, float, float, float, float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_107calculate_interception(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_107calculate_interception = {"calculate_interception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_107calculate_interception, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_107calculate_interception(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_ship_pos_x;
  double __pyx_v_ship_pos_y;
  double __pyx_v_asteroid_pos_x;
  double __pyx_v_asteroid_pos_y;
  double __pyx_v_asteroid_vel_x;
  double __pyx_v_asteroid_vel_y;
  double __pyx_v_asteroid_r;
  double __pyx_v_ship_heading_deg;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  PyObject *__pyx_v_future_shooting_timesteps = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("calculate_interception (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ship_pos_x,&__pyx_mstate_global->__pyx_n_u_ship_pos_y,&__pyx_mstate_global->__pyx_n_u_asteroid_pos_x,&__pyx_mstate_global->__pyx_n_u_asteroid_pos_y,&__pyx_mstate_global->__pyx_n_u_asteroid_vel_x,&__pyx_mstate_global->__pyx_n_u_asteroid_vel_y,&__pyx_mstate_global->__pyx_n_u_asteroid_r,&__pyx_mstate_global->__pyx_n_u_ship_heading_deg,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_future_shooting_timesteps,0};
  PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2809, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "calculate_interception", 0) < 0) __PYX_ERR(0, 2809, __pyx_L3_error)
      if (!values[9]) values[9] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
      for (Py_ssize_t i = __pyx_nargs; i < 9; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("calculate_interception", 0, 9, 10, i); __PYX_ERR(0, 2809, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2809, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2809, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[9]) values[9] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
    }
    __pyx_v_ship_pos_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_ship_pos_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_ship_pos_y = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_ship_pos_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_asteroid_pos_x = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_asteroid_pos_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_asteroid_pos_y = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_asteroid_pos_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_asteroid_vel_x = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_asteroid_vel_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_asteroid_vel_y = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_asteroid_vel_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_asteroid_r = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_asteroid_r == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_ship_heading_deg = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_ship_heading_deg == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2809, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[8]);
    __pyx_v_future_shooting_timesteps = ((PyObject*)values[9]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("calculate_interception", 0, 9, 10, __pyx_nargs); __PYX_ERR(0, 2809, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.calculate_interception", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_future_shooting_timesteps), (&PyLong_Type), 0, "future_shooting_timesteps", 2))) __PYX_ERR(0, 2809, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_106calculate_interception(__pyx_self, __pyx_v_ship_pos_x, __pyx_v_ship_pos_y, __pyx_v_asteroid_pos_x, __pyx_v_asteroid_pos_y, __pyx_v_asteroid_vel_x, __pyx_v_asteroid_vel_y, __pyx_v_asteroid_r, __pyx_v_ship_heading_deg, __pyx_v_game_state, __pyx_v_future_shooting_timesteps);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_106calculate_interception(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_ship_pos_x, double __pyx_v_ship_pos_y, double __pyx_v_asteroid_pos_x, double __pyx_v_asteroid_pos_y, double __pyx_v_asteroid_vel_x, double __pyx_v_asteroid_vel_y, double __pyx_v_asteroid_r, double __pyx_v_ship_heading_deg, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, PyObject *__pyx_v_future_shooting_timesteps) {
  double __pyx_v_t_0;
  double __pyx_v_origin_x;
  double __pyx_v_origin_y;
  double __pyx_v_avx;
  double __pyx_v_avy;
  PyObject *__pyx_v_ax = NULL;
  PyObject *__pyx_v_ay = NULL;
  PyObject *__pyx_v_vb = NULL;
  PyObject *__pyx_v_vb_sq = NULL;
  PyObject *__pyx_v_theta_0 = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_time_until_can_fire_s = NULL;
  PyObject *__pyx_v_ax_delayed = NULL;
  PyObject *__pyx_v_ay_delayed = NULL;
  PyObject *__pyx_v_b = NULL;
  PyObject *__pyx_v_c = NULL;
  PyObject *__pyx_v_t = NULL;
  PyObject *__pyx_v_x = NULL;
  PyObject *__pyx_v_y = NULL;
  PyObject *__pyx_v_theta = NULL;
  PyObject *__pyx_v_intercept_x = NULL;
  PyObject *__pyx_v_intercept_y = NULL;
  PyObject *__pyx_v_feasible = NULL;
  double __pyx_v_asteroid_dist;
  PyObject *__pyx_v_shot_heading_tolerance_rad = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_AddTraceback("neo_controller.calculate_interception", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ax);
  __Pyx_XDECREF(__pyx_v_ay);
  __Pyx_XDECREF(__pyx_v_vb);
  __Pyx_XDECREF(__pyx_v_vb_sq);
  __Pyx_XDECREF(__pyx_v_theta_0);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_time_until_can_fire_s);
  __Pyx_XDECREF(__pyx_v_ax_delayed);
  __Pyx_XDECREF(__pyx_v_ay_delayed);
  __Pyx_XDECREF(__pyx_v_b);
  __Pyx_XDECREF(__pyx_v_c);
  __Pyx_XDECREF(__pyx_v_t);
  __Pyx_XDECREF(__pyx_v_x);
  __Pyx_XDECREF(__pyx_v_y);
  __Pyx_XDECREF(__pyx_v_theta);
  __Pyx_XDECREF(__pyx_v_intercept_x);
  __Pyx_XDECREF(__pyx_v_intercept_y);
  __Pyx_XDECREF(__pyx_v_feasible);
  __Pyx_XDECREF(__pyx_v_shot_heading_tolerance_rad);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2809, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_pos_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_pos_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid_pos_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid_pos_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid_vel_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid_vel_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid_r, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_heading_deg, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_future_shooting_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_bool_float_float_float_flo) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_107calculate_interception, 0, __pyx_mstate_global->__pyx_n_u_calculate_interception, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[126])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2809, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_mstate_global->__pyx_tuple[18]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_calculate_interception, __pyx_t_9) < 0) __PYX_ERR(0, 2809, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 2810:     # This is a simplified version of solve_interception(). This will, given the position of the ship and an asteroid, tell you which angle you need to fire at after future_shooting_timesteps to shoot the asteroid

 2811:     # The bullet's head originates from the edge of the ship's radius.

 2812:     # We want to set the position of the bullet to the center of the bullet, so we have to do some fanciness here so that at t=0, the bullet's center is where it should be

+2813:     t_0 = 0.0175 # t_0 = (SHIP_RADIUS - 0.5*BULLET_LENGTH)/BULLET_SPEED

  __pyx_v_t_0 = 0.0175;

 2814:     # Positions are relative to the ship. We set the origin to the ship's position. Remember to translate back!

+2815:     origin_x = ship_pos_x

  __pyx_v_origin_x = __pyx_v_ship_pos_x;

+2816:     origin_y = ship_pos_y

  __pyx_v_origin_y = __pyx_v_ship_pos_y;

+2817:     avx = asteroid_vel_x

  __pyx_v_avx = __pyx_v_asteroid_vel_x;

+2818:     avy = asteroid_vel_y

  __pyx_v_avy = __pyx_v_asteroid_vel_y;

+2819:     ax = asteroid_pos_x - origin_x + avx*DELTA_TIME  # We project the asteroid one timestep ahead, since by the time we shoot our bullet, the asteroid would have moved one more timestep!

  __pyx_t_1 = PyFloat_FromDouble((__pyx_v_asteroid_pos_x - __pyx_v_origin_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2819, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_avx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2819, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2819, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2819, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2819, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_ax = __pyx_t_3;
  __pyx_t_3 = 0;

+2820:     ay = asteroid_pos_y - origin_y + avy*DELTA_TIME

  __pyx_t_3 = PyFloat_FromDouble((__pyx_v_asteroid_pos_y - __pyx_v_origin_y)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_avy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_ay = __pyx_t_1;
  __pyx_t_1 = 0;

 2821: 

+2822:     vb = BULLET_SPEED

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2822, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_vb = __pyx_t_1;
  __pyx_t_1 = 0;

+2823:     vb_sq = vb*vb

  __pyx_t_1 = PyNumber_Multiply(__pyx_v_vb, __pyx_v_vb); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_vb_sq = __pyx_t_1;
  __pyx_t_1 = 0;

+2824:     theta_0 = radians(ship_heading_deg)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ship_heading_deg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2824, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_theta_0 = __pyx_t_1;
  __pyx_t_1 = 0;

 2825: 

 2826:     # Calculate constants for naive_desired_heading_calc

+2827:     a = avx*avx + avy*avy - vb_sq

  __pyx_t_1 = PyFloat_FromDouble(((__pyx_v_avx * __pyx_v_avx) + (__pyx_v_avy * __pyx_v_avy))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2827, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Subtract(__pyx_t_1, __pyx_v_vb_sq); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2827, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_a = __pyx_t_3;
  __pyx_t_3 = 0;

 2828: 

+2829:     time_until_can_fire_s = float(future_shooting_timesteps)*DELTA_TIME

  __pyx_t_6 = PyLong_AsDouble(__pyx_v_future_shooting_timesteps); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2829, __pyx_L1_error)
  __pyx_t_3 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_time_until_can_fire_s = __pyx_t_4;
  __pyx_t_4 = 0;

+2830:     ax_delayed = ax + time_until_can_fire_s*avx  # We add a delay to account for the timesteps until we can fire delay

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_avx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2830, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_time_until_can_fire_s, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2830, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Add(__pyx_v_ax, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2830, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ax_delayed = __pyx_t_4;
  __pyx_t_4 = 0;

+2831:     ay_delayed = ay + time_until_can_fire_s*avy

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_avy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2831, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_time_until_can_fire_s, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2831, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Add(__pyx_v_ay, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2831, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ay_delayed = __pyx_t_4;
  __pyx_t_4 = 0;

 2832: 

+2833:     b = 2.0*(ax_delayed*avx + ay_delayed*avy - vb_sq*t_0)

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_avx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_ax_delayed, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_avy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyNumber_Multiply(__pyx_v_ay_delayed, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_t_0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_vb_sq, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_2_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_b = __pyx_t_1;
  __pyx_t_1 = 0;

+2834:     c = ax_delayed*ax_delayed + ay_delayed*ay_delayed - vb_sq*t_0*t_0

  __pyx_t_1 = PyNumber_Multiply(__pyx_v_ax_delayed, __pyx_v_ax_delayed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Multiply(__pyx_v_ay_delayed, __pyx_v_ay_delayed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_t_0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_vb_sq, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_t_0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2834, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_c = __pyx_t_3;
  __pyx_t_3 = 0;

 2835: 

 2836:     #solutions = []

+2837:     for t in solve_quadratic(a, b, c):

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_solve_quadratic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2837, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_v_a, __pyx_v_b, __pyx_v_c};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2837, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
    __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4);
    __pyx_t_7 = 0;
    __pyx_t_8 = NULL;
  } else {
    __pyx_t_7 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2837, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2837, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  for (;;) {
    if (likely(!__pyx_t_8)) {
      if (likely(PyList_CheckExact(__pyx_t_4))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2837, __pyx_L1_error)
          #endif
          if (__pyx_t_7 >= __pyx_temp) break;
        }
        __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_7);
        ++__pyx_t_7;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2837, __pyx_L1_error)
          #endif
          if (__pyx_t_7 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_7));
        #else
        __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_7);
        #endif
        ++__pyx_t_7;
      }
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2837, __pyx_L1_error)
    } else {
      __pyx_t_3 = __pyx_t_8(__pyx_t_4);
      if (unlikely(!__pyx_t_3)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 2837, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
    __pyx_L3_continue:;
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2838:         if isnan(t) or t < 0.0:

    __pyx_t_10 = __Pyx_PyFloat_AsDouble(__pyx_v_t); if (unlikely((__pyx_t_10 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2838, __pyx_L1_error)
    __pyx_t_11 = isnan(__pyx_t_10);
    if (!__pyx_t_11) {
    } else {
      __pyx_t_9 = __pyx_t_11;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2838, __pyx_L1_error)
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2838, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_9 = __pyx_t_11;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_9) {
/* … */
    }

 2839:             # Invalid interception time

+2840:             continue

      goto __pyx_L3_continue;

+2841:         x = ax_delayed + t*avx

    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_avx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2841, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_t, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2841, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Add(__pyx_v_ax_delayed, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2841, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF_SET(__pyx_v_x, __pyx_t_3);
    __pyx_t_3 = 0;

+2842:         y = ay_delayed + t*avy

    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_avy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2842, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_t, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2842, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Add(__pyx_v_ay_delayed, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2842, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF_SET(__pyx_v_y, __pyx_t_3);
    __pyx_t_3 = 0;

+2843:         theta = fast_atan2(y, x)

    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fast_atan2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2843, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_y, __pyx_v_x};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2843, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_XDECREF_SET(__pyx_v_theta, __pyx_t_3);
    __pyx_t_3 = 0;

 2844:         # If the asteroid is out of bounds, then it will wrap around and this shot isn't feasible

 2845:         # However, if an unwrapped asteroid was passed into this function and the interception is inbounds, then it's a feasible shot

+2846:         intercept_x = x + origin_x

    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_origin_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2846, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = PyNumber_Add(__pyx_v_x, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2846, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_intercept_x, __pyx_t_1);
    __pyx_t_1 = 0;

+2847:         intercept_y = y + origin_y

    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_origin_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2847, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = PyNumber_Add(__pyx_v_y, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2847, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF_SET(__pyx_v_intercept_y, __pyx_t_3);
    __pyx_t_3 = 0;

+2848:         feasible = check_coordinate_bounds(game_state, intercept_x, intercept_y)

    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2848, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_1, ((PyObject *)__pyx_v_game_state), __pyx_v_intercept_x, __pyx_v_intercept_y};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2848, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_XDECREF_SET(__pyx_v_feasible, __pyx_t_3);
    __pyx_t_3 = 0;

+2849:         if not feasible:

    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_feasible); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 2849, __pyx_L1_error)
    __pyx_t_11 = (!__pyx_t_9);
    if (__pyx_t_11) {
/* … */
    }

+2850:             continue

      goto __pyx_L3_continue;

+2851:         asteroid_dist = sqrt(x*x + y*y)

    __pyx_t_3 = PyNumber_Multiply(__pyx_v_x, __pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2851, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_y, __pyx_v_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2851, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2851, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2851, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_asteroid_dist = sqrt(__pyx_t_6);

+2852:         if asteroid_r < asteroid_dist:

    __pyx_t_11 = (__pyx_v_asteroid_r < __pyx_v_asteroid_dist);
    if (__pyx_t_11) {
/* … */
      goto __pyx_L9;
    }

+2853:             shot_heading_tolerance_rad = super_fast_asin((asteroid_r - ASTEROID_AIM_BUFFER_PIXELS)/asteroid_dist)

      __pyx_t_2 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_super_fast_asin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2853, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_12 = PyFloat_FromDouble(__pyx_v_asteroid_r); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2853, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_ASTEROID_AIM_BUFFER_PIXELS); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2853, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_14 = PyNumber_Subtract(__pyx_t_12, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2853, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = PyFloat_FromDouble(__pyx_v_asteroid_dist); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2853, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_12 = __Pyx_PyNumber_Divide(__pyx_t_14, __pyx_t_13); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2853, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_2);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_12};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2853, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_v_shot_heading_tolerance_rad = __pyx_t_1;
      __pyx_t_1 = 0;

 2854:         else:

+2855:             shot_heading_tolerance_rad = 0.5*pi

    /*else*/ {
      __pyx_t_1 = PyFloat_FromDouble((0.5 * M_PI)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2855, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_v_shot_heading_tolerance_rad = __pyx_t_1;
      __pyx_t_1 = 0;
    }
    __pyx_L9:;

+2856:         return feasible, angle_difference_rad(theta, theta_0), shot_heading_tolerance_rad, t, intercept_x, intercept_y, asteroid_dist

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_angle_difference_rad); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2856, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_12))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_12);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_theta, __pyx_v_theta_0};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2856, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_12 = PyFloat_FromDouble(__pyx_v_asteroid_dist); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2856, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_3 = PyTuple_New(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2856, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_feasible);
    __Pyx_GIVEREF(__pyx_v_feasible);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_feasible) != (0)) __PYX_ERR(0, 2856, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_1);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 2856, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_shot_heading_tolerance_rad);
    __Pyx_GIVEREF(__pyx_v_shot_heading_tolerance_rad);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_shot_heading_tolerance_rad) != (0)) __PYX_ERR(0, 2856, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_t);
    __Pyx_GIVEREF(__pyx_v_t);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_t) != (0)) __PYX_ERR(0, 2856, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_intercept_x);
    __Pyx_GIVEREF(__pyx_v_intercept_x);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_v_intercept_x) != (0)) __PYX_ERR(0, 2856, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_intercept_y);
    __Pyx_GIVEREF(__pyx_v_intercept_y);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 5, __pyx_v_intercept_y) != (0)) __PYX_ERR(0, 2856, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_12);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 6, __pyx_t_12) != (0)) __PYX_ERR(0, 2856, __pyx_L1_error);
    __pyx_t_1 = 0;
    __pyx_t_12 = 0;
    __pyx_r = ((PyObject*)__pyx_t_3);
    __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L0;

 2857:     #if len(solutions) > 1:

 2858:     #    print(len(solutions))

 2859:     #return solutions

+2860:     return False, NAN, NAN, NAN, NAN, NAN, NAN

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_12 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_13 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_14 = PyTuple_New(7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __Pyx_INCREF(Py_False);
  __Pyx_GIVEREF(Py_False);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, Py_False) != (0)) __PYX_ERR(0, 2860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 2860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 3, __pyx_t_12) != (0)) __PYX_ERR(0, 2860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 4, __pyx_t_1) != (0)) __PYX_ERR(0, 2860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 5, __pyx_t_2) != (0)) __PYX_ERR(0, 2860, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_13);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 6, __pyx_t_13) != (0)) __PYX_ERR(0, 2860, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
  __pyx_t_12 = 0;
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_t_13 = 0;
  __pyx_r = ((PyObject*)__pyx_t_14);
  __pyx_t_14 = 0;
  goto __pyx_L0;

 2861:     # feasible, shot_heading_error_rad, shot_heading_tolerance_rad, interception_time_s + 0*future_shooting_timesteps*delta_time, intercept_x, intercept_y, asteroid_dist, asteroid_dist_during_interception

 2862: 

 2863: 

+2864: def forecast_asteroid_bullet_splits_from_heading(a: Asteroid, timesteps_until_appearance: int, bullet_heading_deg: float, game_state: GameState) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_109forecast_asteroid_bullet_splits_from_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_109forecast_asteroid_bullet_splits_from_heading = {"forecast_asteroid_bullet_splits_from_heading", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_109forecast_asteroid_bullet_splits_from_heading, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_109forecast_asteroid_bullet_splits_from_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a = 0;
  PyObject *__pyx_v_timesteps_until_appearance = 0;
  double __pyx_v_bullet_heading_deg;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("forecast_asteroid_bullet_splits_from_heading (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance,&__pyx_mstate_global->__pyx_n_u_bullet_heading_deg,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2864, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2864, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2864, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2864, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2864, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "forecast_asteroid_bullet_splits_from_heading", 0) < 0) __PYX_ERR(0, 2864, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("forecast_asteroid_bullet_splits_from_heading", 1, 4, 4, i); __PYX_ERR(0, 2864, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2864, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2864, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2864, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2864, __pyx_L3_error)
    }
    __pyx_v_a = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_timesteps_until_appearance = ((PyObject*)values[1]);
    __pyx_v_bullet_heading_deg = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_bullet_heading_deg == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2864, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("forecast_asteroid_bullet_splits_from_heading", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 2864, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_bullet_splits_from_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "a", 0))) __PYX_ERR(0, 2864, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timesteps_until_appearance), (&PyLong_Type), 0, "timesteps_until_appearance", 2))) __PYX_ERR(0, 2864, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2864, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_108forecast_asteroid_bullet_splits_from_heading(__pyx_self, __pyx_v_a, __pyx_v_timesteps_until_appearance, __pyx_v_bullet_heading_deg, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_108forecast_asteroid_bullet_splits_from_heading(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a, PyObject *__pyx_v_timesteps_until_appearance, double __pyx_v_bullet_heading_deg, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_bullet_heading_rad = NULL;
  PyObject *__pyx_v_bullet_vel_x = NULL;
  PyObject *__pyx_v_bullet_vel_y = NULL;
  PyObject *__pyx_v_vfx = NULL;
  PyObject *__pyx_v_vfy = NULL;
  double __pyx_v_v;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_bullet_splits_from_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_bullet_heading_rad);
  __Pyx_XDECREF(__pyx_v_bullet_vel_x);
  __Pyx_XDECREF(__pyx_v_bullet_vel_y);
  __Pyx_XDECREF(__pyx_v_vfx);
  __Pyx_XDECREF(__pyx_v_vfy);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_a, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 2864, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2864, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bullet_heading_deg, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2864, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2864, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2864, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_109forecast_asteroid_bullet_splits_from_heading, 0, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_bullet_splits, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[127])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_bullet_splits, __pyx_t_2) < 0) __PYX_ERR(0, 2864, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2865:     # assert a.size != 1 # Asteroids of size 1 don't split  # REMOVE_FOR_COMPETITION

 2866:     # Look at asteroid.py in the Kessler game's code

+2867:     bullet_heading_rad = radians(bullet_heading_deg)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2867, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_bullet_heading_deg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2867, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_bullet_heading_rad = __pyx_t_1;
  __pyx_t_1 = 0;

+2868:     bullet_vel_x = cos(bullet_heading_rad)*BULLET_SPEED

  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_v_bullet_heading_rad); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2868, __pyx_L1_error)
  __pyx_t_1 = PyFloat_FromDouble(cos(__pyx_t_6)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2868, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2868, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2868, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_bullet_vel_x = __pyx_t_4;
  __pyx_t_4 = 0;

+2869:     bullet_vel_y = sin(bullet_heading_rad)*BULLET_SPEED

  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_v_bullet_heading_rad); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2869, __pyx_L1_error)
  __pyx_t_4 = PyFloat_FromDouble(sin(__pyx_t_6)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_bullet_vel_y = __pyx_t_1;
  __pyx_t_1 = 0;

+2870:     vfx = (1/(BULLET_MASS + a.mass))*(BULLET_MASS*bullet_vel_x + a.mass*a.velocity[0])

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_4, __pyx_v_bullet_vel_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2870, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_v_vfx = __pyx_t_2;
  __pyx_t_2 = 0;

+2871:     vfy = (1/(BULLET_MASS + a.mass))*(BULLET_MASS*bullet_vel_y + a.mass*a.velocity[1])

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_v_bullet_vel_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_vfy = __pyx_t_1;
  __pyx_t_1 = 0;

+2872:     v = sqrt(vfx*vfx + vfy*vfy)

  __pyx_t_1 = PyNumber_Multiply(__pyx_v_vfx, __pyx_v_vfx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2872, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_v_vfy, __pyx_v_vfy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2872, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2872, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2872, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_v_v = sqrt(__pyx_t_6);

+2873:     return forecast_asteroid_splits(a, timesteps_until_appearance, vfx, vfy, v, 15.0, game_state)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_splits); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_v); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[8] = {__pyx_t_4, ((PyObject *)__pyx_v_a), __pyx_v_timesteps_until_appearance, __pyx_v_vfx, __pyx_v_vfy, __pyx_t_2, __pyx_mstate_global->__pyx_float_15_0, ((PyObject *)__pyx_v_game_state)};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_5, (8-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2873, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }
  if (!(likely(PyList_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_7))) __PYX_ERR(0, 2873, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_7);
  __pyx_t_7 = 0;
  goto __pyx_L0;

 2874: 

 2875: 

+2876: def forecast_instantaneous_asteroid_bullet_splits_from_velocity(a: Asteroid, bullet_velocity: tuple[float, float], game_state: GameState) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_111forecast_instantaneous_asteroid_bullet_splits_from_velocity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_111forecast_instantaneous_asteroid_bullet_splits_from_velocity = {"forecast_instantaneous_asteroid_bullet_splits_from_velocity", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_111forecast_instantaneous_asteroid_bullet_splits_from_velocity, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_111forecast_instantaneous_asteroid_bullet_splits_from_velocity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a = 0;
  __pyx_ctuple_double__and_double __pyx_v_bullet_velocity;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("forecast_instantaneous_asteroid_bullet_splits_from_velocity (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_bullet_velocity,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2876, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "forecast_instantaneous_asteroid_bullet_splits_from_velocity", 0) < 0) __PYX_ERR(0, 2876, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("forecast_instantaneous_asteroid_bullet_splits_from_velocity", 1, 3, 3, i); __PYX_ERR(0, 2876, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2876, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2876, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2876, __pyx_L3_error)
    }
    __pyx_v_a = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_bullet_velocity = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2876, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("forecast_instantaneous_asteroid_bullet_splits_from_velocity", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2876, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.forecast_instantaneous_asteroid_bullet_splits_from_velocity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "a", 0))) __PYX_ERR(0, 2876, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2876, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_110forecast_instantaneous_asteroid_bullet_splits_from_velocity(__pyx_self, __pyx_v_a, __pyx_v_bullet_velocity, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_110forecast_instantaneous_asteroid_bullet_splits_from_velocity(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a, __pyx_ctuple_double__and_double __pyx_v_bullet_velocity, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  double __pyx_v_bullet_vel_x;
  double __pyx_v_bullet_vel_y;
  PyObject *__pyx_v_vfx = NULL;
  PyObject *__pyx_v_vfy = NULL;
  double __pyx_v_v;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("neo_controller.forecast_instantaneous_asteroid_bullet_splits_from_velocity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_vfx);
  __Pyx_XDECREF(__pyx_v_vfy);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_a, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 2876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_bullet_velocity, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2876, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_111forecast_instantaneous_asteroid_bullet_splits_from_velocity, 0, __pyx_mstate_global->__pyx_n_u_forecast_instantaneous_asteroid, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[128])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_forecast_instantaneous_asteroid, __pyx_t_9) < 0) __PYX_ERR(0, 2876, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 2877:     # assert a.size != 1 # Asteroids of size 1 don't split  # REMOVE_FOR_COMPETITION

 2878:     # Look at asteroid.py in the Kessler game's code

+2879:     bullet_vel_x, bullet_vel_y = bullet_velocity

  __pyx_t_1 = __pyx_v_bullet_velocity;
  __pyx_t_2 = __pyx_t_1.f0;
  __pyx_t_3 = __pyx_t_1.f1;
  __pyx_v_bullet_vel_x = __pyx_t_2;
  __pyx_v_bullet_vel_y = __pyx_t_3;

+2880:     vfx = (1/(BULLET_MASS + a.mass))*(BULLET_MASS*bullet_vel_x + a.mass*a.velocity[0])

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_bullet_vel_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyNumber_Multiply(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_6, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyNumber_Add(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_5, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_v_vfx = __pyx_t_6;
  __pyx_t_6 = 0;

+2881:     vfy = (1/(BULLET_MASS + a.mass))*(BULLET_MASS*bullet_vel_y + a.mass*a.velocity[1])

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = PyNumber_Add(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_bullet_vel_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_a->mass); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Add(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_vfy = __pyx_t_5;
  __pyx_t_5 = 0;

+2882:     v = sqrt(vfx*vfx + vfy*vfy)

  __pyx_t_5 = PyNumber_Multiply(__pyx_v_vfx, __pyx_v_vfx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Multiply(__pyx_v_vfy, __pyx_v_vfy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_8); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2882, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_v_v = sqrt(__pyx_t_3);

+2883:     return forecast_asteroid_splits(a, 0, vfx, vfy, v, 15.0, game_state)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_splits); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[8] = {__pyx_t_4, ((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_int_0, __pyx_v_vfx, __pyx_v_vfy, __pyx_t_7, __pyx_mstate_global->__pyx_float_15_0, ((PyObject *)__pyx_v_game_state)};
    __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_9, (8-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2883, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
  }
  if (!(likely(PyList_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_8))) __PYX_ERR(0, 2883, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_8);
  __pyx_t_8 = 0;
  goto __pyx_L0;

 2884: 

 2885: 

+2886: def forecast_asteroid_mine_instantaneous_splits(asteroid: Asteroid, mine: Mine, game_state: GameState) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_113forecast_asteroid_mine_instantaneous_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_113forecast_asteroid_mine_instantaneous_splits = {"forecast_asteroid_mine_instantaneous_splits", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_113forecast_asteroid_mine_instantaneous_splits, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_113forecast_asteroid_mine_instantaneous_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  struct __pyx_obj_14neo_controller_Mine *__pyx_v_mine = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("forecast_asteroid_mine_instantaneous_splits (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_mine,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2886, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2886, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2886, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2886, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "forecast_asteroid_mine_instantaneous_splits", 0) < 0) __PYX_ERR(0, 2886, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("forecast_asteroid_mine_instantaneous_splits", 1, 3, 3, i); __PYX_ERR(0, 2886, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2886, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2886, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2886, __pyx_L3_error)
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_mine = ((struct __pyx_obj_14neo_controller_Mine *)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("forecast_asteroid_mine_instantaneous_splits", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2886, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_mine_instantaneous_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 2886, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_ptype_14neo_controller_Mine, 0, "mine", 0))) __PYX_ERR(0, 2886, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2886, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_112forecast_asteroid_mine_instantaneous_splits(__pyx_self, __pyx_v_asteroid, __pyx_v_mine, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_112forecast_asteroid_mine_instantaneous_splits(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, struct __pyx_obj_14neo_controller_Mine *__pyx_v_mine, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  double __pyx_v_dist;
  PyObject *__pyx_v_F = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_cos_theta = NULL;
  PyObject *__pyx_v_sin_theta = NULL;
  PyObject *__pyx_v_vfx = NULL;
  PyObject *__pyx_v_vfy = NULL;
  double __pyx_v_v;
  double __pyx_v_split_angle;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_mine_instantaneous_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_F);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_cos_theta);
  __Pyx_XDECREF(__pyx_v_sin_theta);
  __Pyx_XDECREF(__pyx_v_vfx);
  __Pyx_XDECREF(__pyx_v_vfy);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 2886, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_mine, __pyx_mstate_global->__pyx_n_u_Mine) < 0) __PYX_ERR(0, 2886, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2886, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2886, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_113forecast_asteroid_mine_instantaneous_splits, 0, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_mine_instantan, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[129])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_mine_instantan, __pyx_t_2) < 0) __PYX_ERR(0, 2886, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2887:     # assert asteroid.size != 1 # Asteroids of size 1 don't split  # REMOVE_FOR_COMPETITION

+2888:     delta_x = mine.position[0] - asteroid.position[0]

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_delta_x = __pyx_t_1;
  __pyx_t_1 = 0;

+2889:     delta_y = mine.position[1] - asteroid.position[1]

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_delta_y = __pyx_t_1;
  __pyx_t_1 = 0;

+2890:     dist = sqrt(delta_x*delta_x + delta_y*delta_y)

  __pyx_t_1 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2890, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_dist = sqrt(__pyx_t_4);

+2891:     F = (-dist/MINE_BLAST_RADIUS + 1.0)*MINE_BLAST_PRESSURE*2.0*asteroid.radius

  __pyx_t_3 = PyFloat_FromDouble((-__pyx_v_dist)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyFloat_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_float_1_0, 1.0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_PRESSURE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_3, __pyx_mstate_global->__pyx_float_2_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_asteroid->radius); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_F = __pyx_t_2;
  __pyx_t_2 = 0;

+2892:     a = F/asteroid.mass

  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_v_F, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_a = __pyx_t_3;
  __pyx_t_3 = 0;

 2893:     # calculate "impulse" based on acc

+2894:     if dist != 0.0:

  __pyx_t_5 = (__pyx_v_dist != 0.0);
  if (__pyx_t_5) {
/* … */
    goto __pyx_L3;
  }

+2895:         cos_theta = (asteroid.position[0] - mine.position[0])/dist

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_dist); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_cos_theta = __pyx_t_2;
    __pyx_t_2 = 0;

+2896:         sin_theta = (asteroid.position[1] - mine.position[1])/dist

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_dist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_sin_theta = __pyx_t_1;
    __pyx_t_1 = 0;

+2897:         vfx = asteroid.velocity[0] + a*cos_theta

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyNumber_Multiply(__pyx_v_a, __pyx_v_cos_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_vfx = __pyx_t_2;
    __pyx_t_2 = 0;

+2898:         vfy = asteroid.velocity[1] + a*sin_theta

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2898, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2898, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_a, __pyx_v_sin_theta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2898, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2898, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_vfy = __pyx_t_3;
    __pyx_t_3 = 0;

+2899:         v = sqrt(vfx*vfx + vfy*vfy)

    __pyx_t_3 = PyNumber_Multiply(__pyx_v_vfx, __pyx_v_vfx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2899, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_vfy, __pyx_v_vfy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2899, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2899, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2899, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_v = sqrt(__pyx_t_4);

+2900:         split_angle = 15.0

    __pyx_v_split_angle = 15.0;

 2901:     else:

+2902:         vfx = asteroid.velocity[0]

  /*else*/ {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2902, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2902, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_vfx = __pyx_t_2;
    __pyx_t_2 = 0;

+2903:         vfy = asteroid.velocity[1]

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2903, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2903, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_vfy = __pyx_t_1;
    __pyx_t_1 = 0;

+2904:         v = sqrt(vfx*vfx + vfy*vfy + a*a)

    __pyx_t_1 = PyNumber_Multiply(__pyx_v_vfx, __pyx_v_vfx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_vfy, __pyx_v_vfy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_a, __pyx_v_a); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2904, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_v = sqrt(__pyx_t_4);

+2905:         split_angle = 120.0

    __pyx_v_split_angle = 120.0;
  }
  __pyx_L3:;

+2906:     return forecast_asteroid_splits(asteroid, 0, vfx, vfy, v, split_angle, game_state)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_splits); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_v); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_split_angle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_8 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[8] = {__pyx_t_2, ((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_int_0, __pyx_v_vfx, __pyx_v_vfy, __pyx_t_6, __pyx_t_7, ((PyObject *)__pyx_v_game_state)};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (8-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2906, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 2906, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 2907: 

 2908: 

+2909: def forecast_asteroid_ship_splits(asteroid: Asteroid, timesteps_until_appearance: int, ship_velocity: tuple[float, float], game_state: GameState) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_115forecast_asteroid_ship_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_115forecast_asteroid_ship_splits = {"forecast_asteroid_ship_splits", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_115forecast_asteroid_ship_splits, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_115forecast_asteroid_ship_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  PyObject *__pyx_v_timesteps_until_appearance = 0;
  __pyx_ctuple_double__and_double __pyx_v_ship_velocity;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("forecast_asteroid_ship_splits (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance,&__pyx_mstate_global->__pyx_n_u_ship_velocity,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2909, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2909, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2909, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2909, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2909, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "forecast_asteroid_ship_splits", 0) < 0) __PYX_ERR(0, 2909, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("forecast_asteroid_ship_splits", 1, 4, 4, i); __PYX_ERR(0, 2909, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2909, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2909, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2909, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2909, __pyx_L3_error)
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_timesteps_until_appearance = ((PyObject*)values[1]);
    __pyx_v_ship_velocity = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[2]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2909, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("forecast_asteroid_ship_splits", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 2909, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_ship_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 2909, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timesteps_until_appearance), (&PyLong_Type), 0, "timesteps_until_appearance", 2))) __PYX_ERR(0, 2909, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2909, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_114forecast_asteroid_ship_splits(__pyx_self, __pyx_v_asteroid, __pyx_v_timesteps_until_appearance, __pyx_v_ship_velocity, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_114forecast_asteroid_ship_splits(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, PyObject *__pyx_v_timesteps_until_appearance, __pyx_ctuple_double__and_double __pyx_v_ship_velocity, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_vfx = NULL;
  PyObject *__pyx_v_vfy = NULL;
  double __pyx_v_v;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_ship_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_vfx);
  __Pyx_XDECREF(__pyx_v_vfy);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2909, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 2909, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2909, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_velocity, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 2909, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2909, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2909, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_115forecast_asteroid_ship_splits, 0, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_ship_splits, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[130])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2909, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_ship_splits, __pyx_t_9) < 0) __PYX_ERR(0, 2909, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 2910:     # assert asteroid.size != 1 # Asteroids of size 1 don't split  # REMOVE_FOR_COMPETITION

+2911:     vfx = (1/(SHIP_MASS + asteroid.mass))*(SHIP_MASS*ship_velocity[0] + asteroid.mass*asteroid.velocity[0])

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_SHIP_MASS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MASS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_ship_velocity.f0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_vfx = __pyx_t_3;
  __pyx_t_3 = 0;

+2912:     vfy = (1/(SHIP_MASS + asteroid.mass))*(SHIP_MASS*ship_velocity[1] + asteroid.mass*asteroid.velocity[1])

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MASS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_mstate_global->__pyx_int_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MASS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_ship_velocity.f1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2912, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_vfy = __pyx_t_2;
  __pyx_t_2 = 0;

+2913:     v = sqrt(vfx*vfx + vfy*vfy)

  __pyx_t_2 = PyNumber_Multiply(__pyx_v_vfx, __pyx_v_vfx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2913, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_vfy, __pyx_v_vfy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2913, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2913, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2913, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_v = sqrt(__pyx_t_6);

+2914:     return forecast_asteroid_splits(asteroid, timesteps_until_appearance, vfx, vfy, v, 15.0, game_state)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_splits); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_v); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[8] = {__pyx_t_1, ((PyObject *)__pyx_v_asteroid), __pyx_v_timesteps_until_appearance, __pyx_v_vfx, __pyx_v_vfy, __pyx_t_4, __pyx_mstate_global->__pyx_float_15_0, ((PyObject *)__pyx_v_game_state)};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (8-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2914, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_5))) __PYX_ERR(0, 2914, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_5);
  __pyx_t_5 = 0;
  goto __pyx_L0;

 2915: 

 2916: 

+2917: def forecast_asteroid_splits(a: Asteroid, timesteps_until_appearance: int, vfx: float, vfy: float, v: float, split_angle: float, game_state: GameState) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_117forecast_asteroid_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_117forecast_asteroid_splits = {"forecast_asteroid_splits", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_117forecast_asteroid_splits, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_117forecast_asteroid_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a = 0;
  PyObject *__pyx_v_timesteps_until_appearance = 0;
  double __pyx_v_vfx;
  double __pyx_v_vfy;
  double __pyx_v_v;
  double __pyx_v_split_angle;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("forecast_asteroid_splits (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance,&__pyx_mstate_global->__pyx_n_u_vfx,&__pyx_mstate_global->__pyx_n_u_vfy,&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_split_angle,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[7] = {0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2917, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2917, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2917, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2917, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2917, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2917, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2917, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2917, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "forecast_asteroid_splits", 0) < 0) __PYX_ERR(0, 2917, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 7; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("forecast_asteroid_splits", 1, 7, 7, i); __PYX_ERR(0, 2917, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 7)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2917, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2917, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2917, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2917, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2917, __pyx_L3_error)
      values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2917, __pyx_L3_error)
      values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2917, __pyx_L3_error)
    }
    __pyx_v_a = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_timesteps_until_appearance = ((PyObject*)values[1]);
    __pyx_v_vfx = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfx == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error)
    __pyx_v_vfy = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_vfy == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error)
    __pyx_v_v = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_v == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error)
    __pyx_v_split_angle = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_split_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[6]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("forecast_asteroid_splits", 1, 7, 7, __pyx_nargs); __PYX_ERR(0, 2917, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "a", 0))) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timesteps_until_appearance), (&PyLong_Type), 0, "timesteps_until_appearance", 2))) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2917, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_116forecast_asteroid_splits(__pyx_self, __pyx_v_a, __pyx_v_timesteps_until_appearance, __pyx_v_vfx, __pyx_v_vfy, __pyx_v_v, __pyx_v_split_angle, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_116forecast_asteroid_splits(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a, PyObject *__pyx_v_timesteps_until_appearance, double __pyx_v_vfx, double __pyx_v_vfy, double __pyx_v_v, double __pyx_v_split_angle, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_theta = NULL;
  PyObject *__pyx_v_angles = NULL;
  long __pyx_v_new_size;
  PyObject *__pyx_v_new_mass = NULL;
  PyObject *__pyx_v_new_radius = NULL;
  PyObject *__pyx_9genexpr16__pyx_v_angle = NULL;
  PyObject *__pyx_9genexpr17__pyx_v_angle = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("neo_controller.forecast_asteroid_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_theta);
  __Pyx_XDECREF(__pyx_v_angles);
  __Pyx_XDECREF(__pyx_v_new_mass);
  __Pyx_XDECREF(__pyx_v_new_radius);
  __Pyx_XDECREF(__pyx_9genexpr16__pyx_v_angle);
  __Pyx_XDECREF(__pyx_9genexpr17__pyx_v_angle);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_a, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_vfx, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_vfy, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_v, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_split_angle, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_117forecast_asteroid_splits, 0, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_splits, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[131])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_splits, __pyx_t_2) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2918:     # Calculate angle of center asteroid for split (degrees)

+2919:     theta = degrees(atan2(vfy, vfx)) # DO NOT USE AN APPROXIMATION FOR ATAN2!! This needs to match Kessler or else we can get desyncs.

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2919, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(atan2(__pyx_v_vfy, __pyx_v_vfx)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2919, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2919, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_theta = __pyx_t_1;
  __pyx_t_1 = 0;

 2920:     # Split angle is the angle off of the new velocity vector for the two asteroids to the sides, the center child asteroid continues on the new velocity path

+2921:     angles = (radians(theta + split_angle), radians(theta), radians(theta - split_angle))

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_split_angle); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = PyNumber_Add(__pyx_v_theta, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2921, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_theta};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2921, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_split_angle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyNumber_Subtract(__pyx_v_theta, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_8};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2921, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2921, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2921, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 2921, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
  __pyx_v_angles = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 2922:     # We redundantly convert to degrees, add split angle, and back to radians. But it has to do this to match Kessler. No way to optimize without risking desyncs.

 2923:     # This is wacky because we're back-extrapolation the position of the asteroid BEFORE IT WAS BORN!!!!11!

+2924:     new_size = a.size - 1

  __pyx_v_new_size = (__pyx_v_a->size - 1);

+2925:     new_mass = ASTEROID_MASS_LOOKUP[new_size]

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ASTEROID_MASS_LOOKUP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_new_size, long, 1, __Pyx_PyLong_From_long, 0, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_new_mass = __pyx_t_3;
  __pyx_t_3 = 0;

+2926:     new_radius = ASTEROID_RADII_LOOKUP[new_size]

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROID_RADII_LOOKUP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_3, __pyx_v_new_size, long, 1, __Pyx_PyLong_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_new_radius = __pyx_t_2;
  __pyx_t_2 = 0;

 2927: 

+2928:     if timesteps_until_appearance == 0:

  __pyx_t_9 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_timesteps_until_appearance, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 2928, __pyx_L1_error)
  if (__pyx_t_9) {
/* … */
  }

+2929:         return [

    __Pyx_XDECREF(__pyx_r);
    { /* enter inner scope */
      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2929, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_2);

+2930:             Asteroid(

        __pyx_t_1 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
        __pyx_t_8 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 

+2931:                 position=a.position,

        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2931, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_6);

+2932:                 velocity=(v*cos(angle), v*sin(angle)),

        __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_9genexpr16__pyx_v_angle); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2932, __pyx_L6_error)
        __pyx_t_7 = PyFloat_FromDouble((__pyx_v_v * cos(__pyx_t_11))); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2932, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_9genexpr16__pyx_v_angle); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2932, __pyx_L6_error)
        __pyx_t_12 = PyFloat_FromDouble((__pyx_v_v * sin(__pyx_t_11))); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2932, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2932, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_GIVEREF(__pyx_t_7);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 2932, __pyx_L6_error);
        __Pyx_GIVEREF(__pyx_t_12);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 2932, __pyx_L6_error);
        __pyx_t_7 = 0;
        __pyx_t_12 = 0;

+2933:                 size=new_size,

        __pyx_t_12 = __Pyx_PyLong_From_long(__pyx_v_new_size); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2933, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_12);

 2934:                 mass=new_mass,

+2935:                 radius=new_radius,

        __pyx_t_5 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_1, NULL};
          __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2930, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_7);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_6, __pyx_t_7, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2930, __pyx_L6_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_13, __pyx_t_7, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 2930, __pyx_L6_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_12, __pyx_t_7, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 2930, __pyx_L6_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_v_new_mass, __pyx_t_7, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 2930, __pyx_L6_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_v_new_radius, __pyx_t_7, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 2930, __pyx_L6_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 2930, __pyx_L6_error)
          __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_8, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2930, __pyx_L6_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_4);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 2929, __pyx_L6_error)
        __Pyx_DECREF((PyObject *)__pyx_t_4); __pyx_t_4 = 0;

 2936:                 timesteps_until_appearance=0

+2937:             ) for angle in angles

      __pyx_t_3 = __pyx_v_angles; __Pyx_INCREF(__pyx_t_3);
      __pyx_t_10 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2937, __pyx_L6_error)
          #endif
          if (__pyx_t_10 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_10));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_10);
        #endif
        ++__pyx_t_10;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2937, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_XDECREF_SET(__pyx_9genexpr16__pyx_v_angle, __pyx_t_4);
        __pyx_t_4 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_9genexpr16__pyx_v_angle); __pyx_9genexpr16__pyx_v_angle = 0;
      goto __pyx_L10_exit_scope;
      __pyx_L6_error:;
      __Pyx_XDECREF(__pyx_9genexpr16__pyx_v_angle); __pyx_9genexpr16__pyx_v_angle = 0;
      goto __pyx_L1_error;
      __pyx_L10_exit_scope:;
    } /* exit inner scope */
    __pyx_r = ((PyObject*)__pyx_t_2);
    __pyx_t_2 = 0;
    goto __pyx_L0;

 2938:         ]

 2939:     else:

+2940:         return [

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    { /* enter inner scope */
      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2940, __pyx_L13_error)
      __Pyx_GOTREF(__pyx_t_2);

+2941:             Asteroid(

        __pyx_t_8 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
        __pyx_t_7 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 

 2942:                 position=(

+2943:                     (a.position[0] + a.velocity[0]*DELTA_TIME*float(timesteps_until_appearance) - float(timesteps_until_appearance)*cos(angle)*v*DELTA_TIME) % game_state.map_size[0],

        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_12, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_12, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_1 = PyNumber_Multiply(__pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_11 = PyLong_AsDouble(__pyx_v_timesteps_until_appearance); if (unlikely(__pyx_t_11 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2943, __pyx_L13_error)
        __pyx_t_12 = PyFloat_FromDouble(__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = PyNumber_Add(__pyx_t_13, __pyx_t_6); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_11 = PyLong_AsDouble(__pyx_v_timesteps_until_appearance); if (unlikely(__pyx_t_11 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2943, __pyx_L13_error)
        __pyx_t_14 = __Pyx_PyFloat_AsDouble(__pyx_9genexpr17__pyx_v_angle); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2943, __pyx_L13_error)
        __pyx_t_6 = PyFloat_FromDouble(((__pyx_t_11 * cos(__pyx_t_14)) * __pyx_v_v)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_1 = PyNumber_Multiply(__pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = PyNumber_Subtract(__pyx_t_12, __pyx_t_1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyNumber_Remainder(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
/* … */
        __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_GIVEREF(__pyx_t_1);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2943, __pyx_L13_error);
        __Pyx_GIVEREF(__pyx_t_15);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_15) != (0)) __PYX_ERR(0, 2943, __pyx_L13_error);
        __pyx_t_1 = 0;
        __pyx_t_15 = 0;

+2944:                     (a.position[1] + a.velocity[1]*DELTA_TIME*float(timesteps_until_appearance) - float(timesteps_until_appearance)*sin(angle)*v*DELTA_TIME) % game_state.map_size[1]

        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_15 = PyNumber_Multiply(__pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_14 = PyLong_AsDouble(__pyx_v_timesteps_until_appearance); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2944, __pyx_L13_error)
        __pyx_t_12 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_6 = PyNumber_Multiply(__pyx_t_15, __pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = PyNumber_Add(__pyx_t_13, __pyx_t_6); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_14 = PyLong_AsDouble(__pyx_v_timesteps_until_appearance); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2944, __pyx_L13_error)
        __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_9genexpr17__pyx_v_angle); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2944, __pyx_L13_error)
        __pyx_t_6 = PyFloat_FromDouble(((__pyx_t_14 * sin(__pyx_t_11)) * __pyx_v_v)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_15 = PyNumber_Multiply(__pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = PyNumber_Subtract(__pyx_t_12, __pyx_t_15); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_15, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = PyNumber_Remainder(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2944, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;

 2945:                 ),

+2946:                 velocity=(v*cos(angle), v*sin(angle)),

        __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_9genexpr17__pyx_v_angle); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2946, __pyx_L13_error)
        __pyx_t_15 = PyFloat_FromDouble((__pyx_v_v * cos(__pyx_t_11))); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2946, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_9genexpr17__pyx_v_angle); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2946, __pyx_L13_error)
        __pyx_t_1 = PyFloat_FromDouble((__pyx_v_v * sin(__pyx_t_11))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2946, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2946, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_GIVEREF(__pyx_t_15);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_15) != (0)) __PYX_ERR(0, 2946, __pyx_L13_error);
        __Pyx_GIVEREF(__pyx_t_1);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 2946, __pyx_L13_error);
        __pyx_t_15 = 0;
        __pyx_t_1 = 0;

+2947:                 size=new_size,

        __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_v_new_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2947, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_1);

 2948:                 mass=new_mass,

 2949:                 radius=new_radius,

+2950:                 timesteps_until_appearance=timesteps_until_appearance

        __pyx_t_5 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_8, NULL};
          __pyx_t_15 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2941, __pyx_L13_error)
          __Pyx_GOTREF(__pyx_t_15);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_12, __pyx_t_15, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2941, __pyx_L13_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_13, __pyx_t_15, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 2941, __pyx_L13_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_1, __pyx_t_15, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 2941, __pyx_L13_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_v_new_mass, __pyx_t_15, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 2941, __pyx_L13_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_v_new_radius, __pyx_t_15, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 2941, __pyx_L13_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_v_timesteps_until_appearance, __pyx_t_15, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 2941, __pyx_L13_error)
          __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_7, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_15);
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2941, __pyx_L13_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_4);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 2940, __pyx_L13_error)
        __Pyx_DECREF((PyObject *)__pyx_t_4); __pyx_t_4 = 0;

+2951:             ) for angle in angles

      __pyx_t_3 = __pyx_v_angles; __Pyx_INCREF(__pyx_t_3);
      __pyx_t_10 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2951, __pyx_L13_error)
          #endif
          if (__pyx_t_10 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_10));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_10);
        #endif
        ++__pyx_t_10;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2951, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_XDECREF_SET(__pyx_9genexpr17__pyx_v_angle, __pyx_t_4);
        __pyx_t_4 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_9genexpr17__pyx_v_angle); __pyx_9genexpr17__pyx_v_angle = 0;
      goto __pyx_L17_exit_scope;
      __pyx_L13_error:;
      __Pyx_XDECREF(__pyx_9genexpr17__pyx_v_angle); __pyx_9genexpr17__pyx_v_angle = 0;
      goto __pyx_L1_error;
      __pyx_L17_exit_scope:;
    } /* exit inner scope */
    __pyx_r = ((PyObject*)__pyx_t_2);
    __pyx_t_2 = 0;
    goto __pyx_L0;
  }

 2952:         ]

 2953: 

 2954: 

+2955: def maintain_forecasted_asteroids(forecasted_asteroid_splits: list[Asteroid], game_state: GameState) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_119maintain_forecasted_asteroids(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_119maintain_forecasted_asteroids = {"maintain_forecasted_asteroids", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_119maintain_forecasted_asteroids, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_119maintain_forecasted_asteroids(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_forecasted_asteroid_splits = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("maintain_forecasted_asteroids (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2955, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2955, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2955, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "maintain_forecasted_asteroids", 0) < 0) __PYX_ERR(0, 2955, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("maintain_forecasted_asteroids", 1, 2, 2, i); __PYX_ERR(0, 2955, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2955, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2955, __pyx_L3_error)
    }
    __pyx_v_forecasted_asteroid_splits = ((PyObject*)values[0]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("maintain_forecasted_asteroids", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2955, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.maintain_forecasted_asteroids", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_forecasted_asteroid_splits), (&PyList_Type), 0, "forecasted_asteroid_splits", 2))) __PYX_ERR(0, 2955, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2955, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_118maintain_forecasted_asteroids(__pyx_self, __pyx_v_forecasted_asteroid_splits, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_118maintain_forecasted_asteroids(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_forecasted_asteroid_splits, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_updated_asteroids = NULL;
  PyObject *__pyx_9genexpr18__pyx_v_forecasted_asteroid = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_AddTraceback("neo_controller.maintain_forecasted_asteroids", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_updated_asteroids);
  __Pyx_XDECREF(__pyx_9genexpr18__pyx_v_forecasted_asteroid);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2955, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2955, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2955, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2955, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_119maintain_forecasted_asteroids, 0, __pyx_mstate_global->__pyx_n_u_maintain_forecasted_asteroids, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[132])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2955, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_maintain_forecasted_asteroids, __pyx_t_9) < 0) __PYX_ERR(0, 2955, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 2956:     # Maintain the list of projected split asteroids by advancing the position, decreasing the timestep, and facilitate removal

+2957:     updated_asteroids = [

  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2957, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_1);

+2958:         Asteroid(

        __pyx_t_4 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
        __pyx_t_7 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 

 2959:             position=(

+2960:                 (forecasted_asteroid.position[0] + forecasted_asteroid.velocity[0] * DELTA_TIME) % game_state.map_size[0],

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_11 = PyNumber_Multiply(__pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = PyNumber_Add(__pyx_t_9, __pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_11);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_11, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __pyx_t_11 = PyNumber_Remainder(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
        __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2960, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_GIVEREF(__pyx_t_11);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_11) != (0)) __PYX_ERR(0, 2960, __pyx_L5_error);
        __Pyx_GIVEREF(__pyx_t_12);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 2960, __pyx_L5_error);
        __pyx_t_11 = 0;
        __pyx_t_12 = 0;

+2961:                  (forecasted_asteroid.position[1] + forecasted_asteroid.velocity[1] * DELTA_TIME) % game_state.map_size[1]

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_12 = PyNumber_Multiply(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_Add(__pyx_t_8, __pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = PyNumber_Remainder(__pyx_t_9, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2961, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 2962:             ),

+2963:             velocity=forecasted_asteroid.velocity,

        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2963, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_12);

+2964:             size=forecasted_asteroid.size,

        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2964, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_11);

+2965:             mass=forecasted_asteroid.mass,

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_mass); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2965, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_9);

+2966:             radius=forecasted_asteroid.radius,

        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2966, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_10);

+2967:             timesteps_until_appearance=forecasted_asteroid.timesteps_until_appearance - 1

        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2967, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_14 = __Pyx_PyLong_SubtractObjC(__pyx_t_13, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2967, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_14);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_15 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_4, NULL};
          __pyx_t_13 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2958, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_13);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_8, __pyx_t_13, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 2958, __pyx_L5_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_12, __pyx_t_13, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 2958, __pyx_L5_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_11, __pyx_t_13, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 2958, __pyx_L5_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_9, __pyx_t_13, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 2958, __pyx_L5_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_t_10, __pyx_t_13, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 2958, __pyx_L5_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_t_14, __pyx_t_13, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 2958, __pyx_L5_error)
          __pyx_t_5 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_7, __pyx_callargs+__pyx_t_15, (1-__pyx_t_15) | (__pyx_t_15*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_13);
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2958, __pyx_L5_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_5);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 2957, __pyx_L5_error)
        __Pyx_DECREF((PyObject *)__pyx_t_5); __pyx_t_5 = 0;

+2968:         ) for forecasted_asteroid in forecasted_asteroid_splits if forecasted_asteroid.timesteps_until_appearance > 1

    __pyx_t_2 = __pyx_v_forecasted_asteroid_splits; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2968, __pyx_L5_error)
        #endif
        if (__pyx_t_3 >= __pyx_temp) break;
      }
      __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3);
      ++__pyx_t_3;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2968, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_t_4);
      __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr18__pyx_v_forecasted_asteroid, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2968, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2968, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2968, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_6) {
/* … */
      }
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_9genexpr18__pyx_v_forecasted_asteroid); __pyx_9genexpr18__pyx_v_forecasted_asteroid = 0;
    goto __pyx_L10_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_9genexpr18__pyx_v_forecasted_asteroid); __pyx_9genexpr18__pyx_v_forecasted_asteroid = 0;
    goto __pyx_L1_error;
    __pyx_L10_exit_scope:;
  } /* exit inner scope */
  __pyx_v_updated_asteroids = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 2969:     ]

+2970:     return updated_asteroids

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_updated_asteroids);
  __pyx_r = __pyx_v_updated_asteroids;
  goto __pyx_L0;

 2971: 

+2972: def is_asteroid_in_list(list_of_asteroids: list[Asteroid], asteroid: Asteroid, game_state: GameState) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_121is_asteroid_in_list(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_121is_asteroid_in_list = {"is_asteroid_in_list", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_121is_asteroid_in_list, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_121is_asteroid_in_list(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_list_of_asteroids = 0;
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_asteroid_in_list (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_list_of_asteroids,&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2972, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2972, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2972, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2972, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "is_asteroid_in_list", 0) < 0) __PYX_ERR(0, 2972, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("is_asteroid_in_list", 1, 3, 3, i); __PYX_ERR(0, 2972, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2972, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2972, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2972, __pyx_L3_error)
    }
    __pyx_v_list_of_asteroids = ((PyObject*)values[0]);
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("is_asteroid_in_list", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2972, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.is_asteroid_in_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_list_of_asteroids), (&PyList_Type), 0, "list_of_asteroids", 2))) __PYX_ERR(0, 2972, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 2972, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2972, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_120is_asteroid_in_list(__pyx_self, __pyx_v_list_of_asteroids, __pyx_v_asteroid, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_120is_asteroid_in_list(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_list_of_asteroids, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("neo_controller.is_asteroid_in_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2972, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_list_of_asteroids, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 2972, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 2972, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2972, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 2972, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_121is_asteroid_in_list, 0, __pyx_mstate_global->__pyx_n_u_is_asteroid_in_list, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[133])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2972, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_is_asteroid_in_list, __pyx_t_2) < 0) __PYX_ERR(0, 2972, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2973:     # Since floating point comparison isn't a good idea, break apart the asteroid dict and compare each element manually in a fuzzy way

+2974:     for a in list_of_asteroids:

  __pyx_t_1 = __pyx_v_list_of_asteroids; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2974, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2974, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 2975:         # The reason we do the seemingly redundant checks for position, is that we need to account for wrap. If the game field was 1000 pixels wide, and one asteroid is at 0.0000000001 and the other is at 999.9999999999, they're basically the same asteroid, so we need to realize that.

+2976:         if (is_close(a.position[0], asteroid.position[0]) or is_close_to_zero(game_state.map_size[0] - abs(a.position[0] - asteroid.position[0]))) and (is_close(a.position[1], asteroid.position[1]) or is_close_to_zero(game_state.map_size[1] - abs(a.position[1] - asteroid.position[1]))) and is_close(a.velocity[0], asteroid.velocity[0]) and is_close(a.velocity[1], asteroid.velocity[1]) and a.size == asteroid.size:

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_8, __pyx_t_9};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2976, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (!__pyx_t_11) {
    } else {
      goto __pyx_L7_next_and;
    }
    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = PyNumber_Subtract(__pyx_t_7, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PyNumber_Absolute(__pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = PyNumber_Subtract(__pyx_t_5, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_8};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2976, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_11) {
    } else {
      __pyx_t_4 = __pyx_t_11;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_L7_next_and:;
    __pyx_t_9 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_9);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_9);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_12, __pyx_t_5};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2976, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (!__pyx_t_11) {
    } else {
      goto __pyx_L9_next_and;
    }
    __pyx_t_8 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = PyNumber_Subtract(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyNumber_Absolute(__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = PyNumber_Subtract(__pyx_t_9, __pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_8);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_12};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2976, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_11) {
    } else {
      __pyx_t_4 = __pyx_t_11;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_L9_next_and:;
    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_12))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_7, __pyx_t_9};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2976, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_11) {
    } else {
      __pyx_t_4 = __pyx_t_11;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_12 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_12);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_12);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_12, __pyx_t_5, __pyx_t_8};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2976, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_11) {
    } else {
      __pyx_t_4 = __pyx_t_11;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_asteroid->size); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_9, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 2976, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_4 = __pyx_t_11;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_4) {
/* … */
    }

 2977:             #assert is_close(a.position[0], asteroid.position[0]) and is_close(a.position[1], asteroid.position[1]) and a.velocity[0] == asteroid.velocity[0] and a.velocity[1] == asteroid.velocity[1] and a.size == asteroid.size

+2978:             return True

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_True);
      __pyx_r = Py_True;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;

+2979:     return False

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_False);
  __pyx_r = Py_False;
  goto __pyx_L0;

 2980: 

 2981: 

+2982: def count_asteroids_in_mine_blast_radius(game_state: GameState, mine_x: float, mine_y: float, future_check_timesteps: int) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_123count_asteroids_in_mine_blast_radius(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_123count_asteroids_in_mine_blast_radius = {"count_asteroids_in_mine_blast_radius", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_123count_asteroids_in_mine_blast_radius, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_123count_asteroids_in_mine_blast_radius(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  double __pyx_v_mine_x;
  double __pyx_v_mine_y;
  PyObject *__pyx_v_future_check_timesteps = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("count_asteroids_in_mine_blast_radius (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_mine_x,&__pyx_mstate_global->__pyx_n_u_mine_y,&__pyx_mstate_global->__pyx_n_u_future_check_timesteps,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2982, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2982, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2982, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2982, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2982, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "count_asteroids_in_mine_blast_radius", 0) < 0) __PYX_ERR(0, 2982, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("count_asteroids_in_mine_blast_radius", 1, 4, 4, i); __PYX_ERR(0, 2982, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2982, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2982, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2982, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2982, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
    __pyx_v_mine_x = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_mine_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2982, __pyx_L3_error)
    __pyx_v_mine_y = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_mine_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2982, __pyx_L3_error)
    __pyx_v_future_check_timesteps = ((PyObject*)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("count_asteroids_in_mine_blast_radius", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 2982, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.count_asteroids_in_mine_blast_radius", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 2982, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_future_check_timesteps), (&PyLong_Type), 0, "future_check_timesteps", 2))) __PYX_ERR(0, 2982, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_122count_asteroids_in_mine_blast_radius(__pyx_self, __pyx_v_game_state, __pyx_v_mine_x, __pyx_v_mine_y, __pyx_v_future_check_timesteps);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_122count_asteroids_in_mine_blast_radius(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, double __pyx_v_mine_x, double __pyx_v_mine_y, PyObject *__pyx_v_future_check_timesteps) {
  PyObject *__pyx_v_count = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_asteroid_future_pos_x = NULL;
  PyObject *__pyx_v_asteroid_future_pos_y = NULL;
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  PyObject *__pyx_v_separation = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.count_asteroids_in_mine_blast_radius", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_count);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_asteroid_future_pos_x);
  __Pyx_XDECREF(__pyx_v_asteroid_future_pos_y);
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_separation);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2982, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 2982, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mine_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2982, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mine_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2982, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_future_check_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2982, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2982, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_123count_asteroids_in_mine_blast_radius, 0, __pyx_mstate_global->__pyx_n_u_count_asteroids_in_mine_blast_ra, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[134])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2982, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_count_asteroids_in_mine_blast_ra, __pyx_t_9) < 0) __PYX_ERR(0, 2982, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+2983:     count = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_count = __pyx_mstate_global->__pyx_int_0;

+2984:     for a in game_state.asteroids:

  if (unlikely(__pyx_v_game_state->asteroids == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 2984, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_v_game_state->asteroids; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2984, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2984, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 2985:         # Extrapolate the asteroid position into the time of the mine detonation to check its bounds

+2986:         asteroid_future_pos_x = (a.position[0] + float(future_check_timesteps)*a.velocity[0]*DELTA_TIME) % game_state.map_size[0]

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_5 = PyLong_AsDouble(__pyx_v_future_check_timesteps); if (unlikely(__pyx_t_5 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2986, __pyx_L1_error)
    __pyx_t_3 = PyFloat_FromDouble(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_6, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = PyNumber_Multiply(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Remainder(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF_SET(__pyx_v_asteroid_future_pos_x, __pyx_t_3);
    __pyx_t_3 = 0;

+2987:         asteroid_future_pos_y = (a.position[1] + float(future_check_timesteps)*a.velocity[1]*DELTA_TIME) % game_state.map_size[1]

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_5 = PyLong_AsDouble(__pyx_v_future_check_timesteps); if (unlikely(__pyx_t_5 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2987, __pyx_L1_error)
    __pyx_t_3 = PyFloat_FromDouble(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Remainder(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2987, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF_SET(__pyx_v_asteroid_future_pos_y, __pyx_t_3);
    __pyx_t_3 = 0;

 2988:         #if check_collision(asteroid_future_pos_x, asteroid_future_pos_y, a.radius, mine_x, mine_y, MINE_BLAST_RADIUS - MINE_ASTEROID_COUNT_FUDGE_DISTANCE):

+2989:         delta_x = asteroid_future_pos_x - mine_x

    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_mine_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2989, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyNumber_Subtract(__pyx_v_asteroid_future_pos_x, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2989, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_4);
    __pyx_t_4 = 0;

+2990:         delta_y = asteroid_future_pos_y - mine_y

    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_mine_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyNumber_Subtract(__pyx_v_asteroid_future_pos_y, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_3);
    __pyx_t_3 = 0;

+2991:         separation = a.radius + (MINE_BLAST_RADIUS - MINE_ASTEROID_COUNT_FUDGE_DISTANCE)

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2991, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2991, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MINE_ASTEROID_COUNT_FUDGE_DISTAN); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2991, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyNumber_Subtract(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2991, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2991, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_6);
    __pyx_t_6 = 0;

+2992:         if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

    __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_9) {
    } else {
      __pyx_t_8 = __pyx_t_9;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_7 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_9) {
    } else {
      __pyx_t_8 = __pyx_t_9;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_6 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = PyNumber_Add(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 2992, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_8 = __pyx_t_9;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_8) {
/* … */
    }

+2993:             count += 1

      __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_v_count, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2993, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF_SET(__pyx_v_count, __pyx_t_6);
      __pyx_t_6 = 0;

+2994:     return count

  __Pyx_XDECREF(__pyx_r);
  if (!(likely(PyLong_CheckExact(__pyx_v_count))||((__pyx_v_count) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_v_count))) __PYX_ERR(0, 2994, __pyx_L1_error)
  __Pyx_INCREF(__pyx_v_count);
  __pyx_r = ((PyObject*)__pyx_v_count);
  goto __pyx_L0;

 2995: 

 2996: 

+2997: def predict_ship_mine_collision(ship_pos_x: float, ship_pos_y: float, mine: Mine, future_timesteps: int = 0) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_125predict_ship_mine_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_125predict_ship_mine_collision = {"predict_ship_mine_collision", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_125predict_ship_mine_collision, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_125predict_ship_mine_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_ship_pos_x;
  double __pyx_v_ship_pos_y;
  struct __pyx_obj_14neo_controller_Mine *__pyx_v_mine = 0;
  PyObject *__pyx_v_future_timesteps = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("predict_ship_mine_collision (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ship_pos_x,&__pyx_mstate_global->__pyx_n_u_ship_pos_y,&__pyx_mstate_global->__pyx_n_u_mine,&__pyx_mstate_global->__pyx_n_u_future_timesteps,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2997, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2997, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2997, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2997, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2997, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "predict_ship_mine_collision", 0) < 0) __PYX_ERR(0, 2997, __pyx_L3_error)
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("predict_ship_mine_collision", 0, 3, 4, i); __PYX_ERR(0, 2997, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2997, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2997, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2997, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2997, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
    }
    __pyx_v_ship_pos_x = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_ship_pos_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2997, __pyx_L3_error)
    __pyx_v_ship_pos_y = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_ship_pos_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2997, __pyx_L3_error)
    __pyx_v_mine = ((struct __pyx_obj_14neo_controller_Mine *)values[2]);
    __pyx_v_future_timesteps = ((PyObject*)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("predict_ship_mine_collision", 0, 3, 4, __pyx_nargs); __PYX_ERR(0, 2997, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.predict_ship_mine_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_ptype_14neo_controller_Mine, 0, "mine", 0))) __PYX_ERR(0, 2997, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_future_timesteps), (&PyLong_Type), 0, "future_timesteps", 2))) __PYX_ERR(0, 2997, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_124predict_ship_mine_collision(__pyx_self, __pyx_v_ship_pos_x, __pyx_v_ship_pos_y, __pyx_v_mine, __pyx_v_future_timesteps);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_124predict_ship_mine_collision(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_ship_pos_x, double __pyx_v_ship_pos_y, struct __pyx_obj_14neo_controller_Mine *__pyx_v_mine, PyObject *__pyx_v_future_timesteps) {
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  PyObject *__pyx_v_separation = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.predict_ship_mine_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_separation);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2997, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_pos_x, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2997, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_pos_y, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2997, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_mine, __pyx_mstate_global->__pyx_n_u_Mine) < 0) __PYX_ERR(0, 2997, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_future_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 2997, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 2997, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_125predict_ship_mine_collision, 0, __pyx_mstate_global->__pyx_n_u_predict_ship_mine_collision, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2997, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[18]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_predict_ship_mine_collision, __pyx_t_2) < 0) __PYX_ERR(0, 2997, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 2998:     # Predicts whether a ship staying where it currently is will be hit by a mine, and when

+2999:     if mine.remaining_time >= float(future_timesteps)*DELTA_TIME:

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_mine->remaining_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2999, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyLong_AsDouble(__pyx_v_future_timesteps); if (unlikely(__pyx_t_2 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2999, __pyx_L1_error)
  __pyx_t_3 = PyFloat_FromDouble(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2999, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2999, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2999, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_5, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2999, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 2999, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_6) {
/* … */
  }

 3000:         #if check_collision(ship_pos_x, ship_pos_y, SHIP_RADIUS, mine.position[0], mine.position[1], MINE_BLAST_RADIUS):

+3001:         delta_x = ship_pos_x - mine.position[0]

    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_ship_pos_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3001, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3001, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3001, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3001, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_delta_x = __pyx_t_5;
    __pyx_t_5 = 0;

+3002:         delta_y = ship_pos_y - mine.position[1]

    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_ship_pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3002, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_mine), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3002, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3002, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyNumber_Subtract(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3002, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_delta_y = __pyx_t_1;
    __pyx_t_1 = 0;

+3003:         separation = SHIP_RADIUS + MINE_BLAST_RADIUS

    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3003, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3003, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3003, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_separation = __pyx_t_5;
    __pyx_t_5 = 0;

+3004:         if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

    __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L5_bool_binop_done;
    }
    __pyx_t_4 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L5_bool_binop_done;
    }
    __pyx_t_5 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 3004, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = __pyx_t_7;
    __pyx_L5_bool_binop_done:;
    if (__pyx_t_6) {
/* … */
    }

+3005:             return mine.remaining_time

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_5 = PyFloat_FromDouble(__pyx_v_mine->remaining_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_r = __pyx_t_5;
      __pyx_t_5 = 0;
      goto __pyx_L0;

 3006:         else:

+3007:             return INFINITY

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_5 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3007, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_r = __pyx_t_5;
      __pyx_t_5 = 0;
      goto __pyx_L0;
    }

 3008:     else:

 3009:         # This mine exploded in the past, so won't ever collide

+3010:         return INFINITY

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3010, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_r = __pyx_t_5;
    __pyx_t_5 = 0;
    goto __pyx_L0;
  }

 3011: 

 3012: 

+3013: def calculate_timesteps_until_bullet_hits_asteroid(time_until_asteroid_center_s: float, asteroid_radius: float) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_127calculate_timesteps_until_bullet_hits_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_127calculate_timesteps_until_bullet_hits_asteroid = {"calculate_timesteps_until_bullet_hits_asteroid", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_127calculate_timesteps_until_bullet_hits_asteroid, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_127calculate_timesteps_until_bullet_hits_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_time_until_asteroid_center_s;
  double __pyx_v_asteroid_radius;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("calculate_timesteps_until_bullet_hits_asteroid (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_time_until_asteroid_center_s,&__pyx_mstate_global->__pyx_n_u_asteroid_radius,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3013, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3013, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3013, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "calculate_timesteps_until_bullet_hits_asteroid", 0) < 0) __PYX_ERR(0, 3013, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("calculate_timesteps_until_bullet_hits_asteroid", 1, 2, 2, i); __PYX_ERR(0, 3013, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3013, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3013, __pyx_L3_error)
    }
    __pyx_v_time_until_asteroid_center_s = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_time_until_asteroid_center_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3013, __pyx_L3_error)
    __pyx_v_asteroid_radius = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_asteroid_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3013, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("calculate_timesteps_until_bullet_hits_asteroid", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3013, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.calculate_timesteps_until_bullet_hits_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_126calculate_timesteps_until_bullet_hits_asteroid(__pyx_self, __pyx_v_time_until_asteroid_center_s, __pyx_v_asteroid_radius);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_126calculate_timesteps_until_bullet_hits_asteroid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_time_until_asteroid_center_s, double __pyx_v_asteroid_radius) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.calculate_timesteps_until_bullet_hits_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3013, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time_until_asteroid_center_s, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3013, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid_radius, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3013, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3013, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_127calculate_timesteps_until_bullet_hits_asteroid, 0, __pyx_mstate_global->__pyx_n_u_calculate_timesteps_until_bullet, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[136])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3013, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_calculate_timesteps_until_bullet, __pyx_t_9) < 0) __PYX_ERR(0, 3013, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 3014:     # time_until_asteroid_center is the time it takes for the bullet to travel from the center of the ship to the center of the asteroid

 3015:     # The bullet originates from the ship's edge, and the collision can happen as early as it touches the radius of the asteroid

 3016:     # We have to add 1, because it takes 1 timestep for the bullet to originate at the start, before it starts moving

+3017:     return 1 + ceil((time_until_asteroid_center_s*BULLET_SPEED - asteroid_radius - SHIP_RADIUS)/BULLET_SPEED*FPS)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ceil); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_time_until_asteroid_center_s); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_asteroid_radius); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyNumber_Subtract(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_6};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3017, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_3 = __Pyx_PyLong_AddCObj(__pyx_mstate_global->__pyx_int_1, __pyx_t_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (!(likely(PyLong_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_3))) __PYX_ERR(0, 3017, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_3);
  __pyx_t_3 = 0;
  goto __pyx_L0;

 3018: 

 3019: 

+3020: def asteroid_bullet_collision(bullet_head_position: tuple[float, float], bullet_tail_position: tuple[float, float], asteroid_center: tuple[float, float], asteroid_radius: float) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_129asteroid_bullet_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_129asteroid_bullet_collision = {"asteroid_bullet_collision", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_129asteroid_bullet_collision, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_129asteroid_bullet_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __pyx_ctuple_double__and_double __pyx_v_bullet_head_position;
  __pyx_ctuple_double__and_double __pyx_v_bullet_tail_position;
  __pyx_ctuple_double__and_double __pyx_v_asteroid_center;
  double __pyx_v_asteroid_radius;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("asteroid_bullet_collision (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_bullet_head_position,&__pyx_mstate_global->__pyx_n_u_bullet_tail_position,&__pyx_mstate_global->__pyx_n_u_asteroid_center,&__pyx_mstate_global->__pyx_n_u_asteroid_radius,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3020, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3020, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3020, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3020, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3020, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "asteroid_bullet_collision", 0) < 0) __PYX_ERR(0, 3020, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("asteroid_bullet_collision", 1, 4, 4, i); __PYX_ERR(0, 3020, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3020, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3020, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3020, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3020, __pyx_L3_error)
    }
    __pyx_v_bullet_head_position = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3020, __pyx_L3_error)
    __pyx_v_bullet_tail_position = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3020, __pyx_L3_error)
    __pyx_v_asteroid_center = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[2]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3020, __pyx_L3_error)
    __pyx_v_asteroid_radius = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_asteroid_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3020, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("asteroid_bullet_collision", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 3020, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.asteroid_bullet_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_128asteroid_bullet_collision(__pyx_self, __pyx_v_bullet_head_position, __pyx_v_bullet_tail_position, __pyx_v_asteroid_center, __pyx_v_asteroid_radius);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_128asteroid_bullet_collision(CYTHON_UNUSED PyObject *__pyx_self, __pyx_ctuple_double__and_double __pyx_v_bullet_head_position, __pyx_ctuple_double__and_double __pyx_v_bullet_tail_position, __pyx_ctuple_double__and_double __pyx_v_asteroid_center, double __pyx_v_asteroid_radius) {
  double __pyx_v_x_min;
  double __pyx_v_x_max;
  double __pyx_v_y_min;
  double __pyx_v_y_max;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_b = NULL;
  PyObject *__pyx_v_s = NULL;
  PyObject *__pyx_v_squared_area = NULL;
  PyObject *__pyx_v_triangle_height = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.asteroid_bullet_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_b);
  __Pyx_XDECREF(__pyx_v_s);
  __Pyx_XDECREF(__pyx_v_squared_area);
  __Pyx_XDECREF(__pyx_v_triangle_height);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3020, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bullet_head_position, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 3020, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bullet_tail_position, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 3020, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroid_center, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 3020, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroid_radius, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3020, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3020, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_129asteroid_bullet_collision, 0, __pyx_mstate_global->__pyx_n_u_asteroid_bullet_collision, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3020, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_asteroid_bullet_collision, __pyx_t_2) < 0) __PYX_ERR(0, 3020, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3021:     # This is an optimized version of circle_line_collision() from the Kessler source code

 3022:     # First, do a rough check if there's no chance the collision can occur

 3023:     # Avoid the use of min/max because it should be a bit faster

+3024:     if bullet_head_position[0] < bullet_tail_position[0]:

  __pyx_t_1 = (__pyx_v_bullet_head_position.f0 < __pyx_v_bullet_tail_position.f0);
  if (__pyx_t_1) {
/* … */
    goto __pyx_L3;
  }

+3025:         x_min = bullet_head_position[0] - asteroid_radius

    __pyx_v_x_min = (__pyx_v_bullet_head_position.f0 - __pyx_v_asteroid_radius);

+3026:         if asteroid_center[0] < x_min:

    __pyx_t_1 = (__pyx_v_asteroid_center.f0 < __pyx_v_x_min);
    if (__pyx_t_1) {
/* … */
    }

+3027:             return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      goto __pyx_L0;

+3028:         x_max = bullet_tail_position[0] + asteroid_radius

    __pyx_v_x_max = (__pyx_v_bullet_tail_position.f0 + __pyx_v_asteroid_radius);

 3029:     else:

+3030:         x_min = bullet_tail_position[0] - asteroid_radius

  /*else*/ {
    __pyx_v_x_min = (__pyx_v_bullet_tail_position.f0 - __pyx_v_asteroid_radius);

+3031:         if asteroid_center[0] < x_min:

    __pyx_t_1 = (__pyx_v_asteroid_center.f0 < __pyx_v_x_min);
    if (__pyx_t_1) {
/* … */
    }

+3032:             return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      goto __pyx_L0;

+3033:         x_max = bullet_head_position[0] + asteroid_radius

    __pyx_v_x_max = (__pyx_v_bullet_head_position.f0 + __pyx_v_asteroid_radius);
  }
  __pyx_L3:;

+3034:     if asteroid_center[0] > x_max:

  __pyx_t_1 = (__pyx_v_asteroid_center.f0 > __pyx_v_x_max);
  if (__pyx_t_1) {
/* … */
  }

+3035:         return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

 3036: 

+3037:     if bullet_head_position[1] < bullet_tail_position[1]:

  __pyx_t_1 = (__pyx_v_bullet_head_position.f1 < __pyx_v_bullet_tail_position.f1);
  if (__pyx_t_1) {
/* … */
    goto __pyx_L7;
  }

+3038:         y_min = bullet_head_position[1] - asteroid_radius

    __pyx_v_y_min = (__pyx_v_bullet_head_position.f1 - __pyx_v_asteroid_radius);

+3039:         if asteroid_center[1] < y_min:

    __pyx_t_1 = (__pyx_v_asteroid_center.f1 < __pyx_v_y_min);
    if (__pyx_t_1) {
/* … */
    }

+3040:             return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      goto __pyx_L0;

+3041:         y_max = bullet_tail_position[1] + asteroid_radius

    __pyx_v_y_max = (__pyx_v_bullet_tail_position.f1 + __pyx_v_asteroid_radius);

 3042:     else:

+3043:         y_min = bullet_tail_position[1] - asteroid_radius

  /*else*/ {
    __pyx_v_y_min = (__pyx_v_bullet_tail_position.f1 - __pyx_v_asteroid_radius);

+3044:         if asteroid_center[1] < y_min:

    __pyx_t_1 = (__pyx_v_asteroid_center.f1 < __pyx_v_y_min);
    if (__pyx_t_1) {
/* … */
    }

+3045:             return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      goto __pyx_L0;

+3046:         y_max = bullet_head_position[1] + asteroid_radius

    __pyx_v_y_max = (__pyx_v_bullet_head_position.f1 + __pyx_v_asteroid_radius);
  }
  __pyx_L7:;

+3047:     if asteroid_center[1] > y_max:

  __pyx_t_1 = (__pyx_v_asteroid_center.f1 > __pyx_v_y_max);
  if (__pyx_t_1) {
/* … */
  }

+3048:         return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

 3049: 

 3050:     # A collision is possible.

 3051:     # Create a triangle between the center of the asteroid, and the two ends of the bullet.

+3052:     a = dist(bullet_head_position, asteroid_center)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_dist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_convert__to_py___pyx_ctuple_double__and_double(__pyx_v_bullet_head_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __pyx_convert__to_py___pyx_ctuple_double__and_double(__pyx_v_asteroid_center); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_5, __pyx_t_6};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3052, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_a = __pyx_t_2;
  __pyx_t_2 = 0;

+3053:     b = dist(bullet_tail_position, asteroid_center)

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_dist); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3053, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __pyx_convert__to_py___pyx_ctuple_double__and_double(__pyx_v_bullet_tail_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3053, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __pyx_convert__to_py___pyx_ctuple_double__and_double(__pyx_v_asteroid_center); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3053, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_t_3};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3053, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_b = __pyx_t_2;
  __pyx_t_2 = 0;

 3054:     #c = BULLET_LENGTH

 3055: 

 3056:     # Heron's formula to calculate area of triangle and resultant height (distance from circle center to line segment)

+3057:     s = 0.5*(a + b + BULLET_LENGTH)

  __pyx_t_2 = PyNumber_Add(__pyx_v_a, __pyx_v_b); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_0_5, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_s = __pyx_t_6;
  __pyx_t_6 = 0;

 3058: 

+3059:     squared_area = s*(s - a)*(s - b)*(s - BULLET_LENGTH)

  __pyx_t_6 = PyNumber_Subtract(__pyx_v_s, __pyx_v_a); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = PyNumber_Multiply(__pyx_v_s, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Subtract(__pyx_v_s, __pyx_v_b); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = PyNumber_Subtract(__pyx_v_s, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3059, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_squared_area = __pyx_t_6;
  __pyx_t_6 = 0;

 3060:     #triangle_height = 2.0/c*sqrt(max(0.0, squared_area))

+3061:     triangle_height = TWICE_BULLET_LENGTH_RECIPROCAL*sqrt(max(0.0, squared_area))

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_TWICE_BULLET_LENGTH_RECIPROCAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_INCREF(__pyx_v_squared_area);
  __pyx_t_3 = __pyx_v_squared_area;
  __pyx_t_8 = 0.0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_2 = __pyx_t_3;
  } else {
    __pyx_t_4 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3061, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __pyx_t_4;
    __pyx_t_4 = 0;
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_8 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(sqrt(__pyx_t_8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_triangle_height = __pyx_t_3;
  __pyx_t_3 = 0;

 3062: 

 3063:     # If triangle's height is less than the asteroid's radius, the bullet is colliding with it

+3064:     return triangle_height < asteroid_radius

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_asteroid_radius); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3064, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyObject_RichCompare(__pyx_v_triangle_height, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3064, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 3065: 

 3066: 

+3067: @lru_cache()  # This function gets called with the same params all the time, so just cache the return value the first time

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_131get_simulated_ship_max_range(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_131get_simulated_ship_max_range = {"get_simulated_ship_max_range", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_131get_simulated_ship_max_range, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_131get_simulated_ship_max_range(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_max_cruise_seconds;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_simulated_ship_max_range (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_max_cruise_seconds,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3067, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3067, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_simulated_ship_max_range", 0) < 0) __PYX_ERR(0, 3067, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_simulated_ship_max_range", 1, 1, 1, i); __PYX_ERR(0, 3067, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3067, __pyx_L3_error)
    }
    __pyx_v_max_cruise_seconds = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_max_cruise_seconds == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3068, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_simulated_ship_max_range", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3067, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_simulated_ship_max_range", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_130get_simulated_ship_max_range(__pyx_self, __pyx_v_max_cruise_seconds);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_130get_simulated_ship_max_range(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_max_cruise_seconds) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_dummy_game_state = NULL;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_dummy_ship_state = NULL;
  PyObject *__pyx_v_max_ship_range_test = NULL;
  PyObject *__pyx_v_state_sequence = NULL;
  PyObject *__pyx_v_ship_random_range = NULL;
  Py_ssize_t __pyx_v_ship_random_max_maneuver_length;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.get_simulated_ship_max_range", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_dummy_game_state);
  __Pyx_XDECREF((PyObject *)__pyx_v_dummy_ship_state);
  __Pyx_XDECREF(__pyx_v_max_ship_range_test);
  __Pyx_XDECREF(__pyx_v_state_sequence);
  __Pyx_XDECREF(__pyx_v_ship_random_range);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = NULL;
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lru_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3067, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3067, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3067, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_max_cruise_seconds, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3067, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_int) < 0) __PYX_ERR(0, 3067, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_131get_simulated_ship_max_range, 0, __pyx_mstate_global->__pyx_n_u_get_simulated_ship_max_range, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[138])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3067, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_3};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3067, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_simulated_ship_max_range, __pyx_t_2) < 0) __PYX_ERR(0, 3067, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3068: def get_simulated_ship_max_range(max_cruise_seconds: float) -> tuple[float, int]:

 3069:     # UNUSED

+3070:     dummy_game_state = GameState(

  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState); 

+3071:         asteroids=[],

  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3071, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+3072:         ships=[],

  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3072, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+3073:         bullets=[],

  __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);

+3074:         mines=[],

  __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3074, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);

+3075:         map_size=(100000.0, 100000.0),

  __pyx_mstate_global->__pyx_tuple[16] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_float_100000_0, __pyx_mstate_global->__pyx_float_100000_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[16])) __PYX_ERR(0, 3075, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[16]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[16]);

 3076:         time=0.0,

+3077:         delta_time=DELTA_TIME,

  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3077, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 8 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3070, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_4, __pyx_t_10, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ships, __pyx_t_5, __pyx_t_10, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_6, __pyx_t_10, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mines, __pyx_t_7, __pyx_t_10, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_map_size, __pyx_mstate_global->__pyx_tuple[16], __pyx_t_10, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_time, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_10, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_delta_time, __pyx_t_8, __pyx_t_10, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_sim_frame, __pyx_mstate_global->__pyx_int_0, __pyx_t_10, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 3070, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3070, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_v_dummy_game_state = ((struct __pyx_obj_14neo_controller_GameState *)__pyx_t_1);
  __pyx_t_1 = 0;

 3078:         sim_frame=0

 3079:     )

+3080:     dummy_ship_state = Ship(

  __pyx_t_3 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship);
  __pyx_t_10 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship); 

 3081:         speed=0.0,

 3082:         position=(0.0, 0.0),

+3083:         velocity=(0.0, 0.0),

  __pyx_t_9 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_3, NULL};
    __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3080, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_speed, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_8, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3080, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_mstate_global->__pyx_tuple[0], __pyx_t_8, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 3080, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_tuple[0], __pyx_t_8, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 3080, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_heading, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_8, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 3080, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_bullets_remaining, __pyx_mstate_global->__pyx_int_0, __pyx_t_8, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 3080, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_lives_remaining, __pyx_mstate_global->__pyx_int_1, __pyx_t_8, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 3080, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_10, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3080, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_v_dummy_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)__pyx_t_1);
  __pyx_t_1 = 0;

 3084:         heading=0.0,

 3085:         bullets_remaining=0,

 3086:         lives_remaining=1

 3087:     )

+3088:     max_ship_range_test = Matrix(dummy_game_state, dummy_ship_state, 0)

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3088, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_10, ((PyObject *)__pyx_v_dummy_game_state), ((PyObject *)__pyx_v_dummy_ship_state), __pyx_mstate_global->__pyx_int_0};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3088, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_max_ship_range_test = __pyx_t_1;
  __pyx_t_1 = 0;

+3089:     max_ship_range_test.accelerate(SHIP_MAX_SPEED)

  __pyx_t_8 = __pyx_v_max_ship_range_test;
  __Pyx_INCREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3089, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_10};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_accelerate, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3089, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3090:     max_ship_range_test.cruise(round(max_cruise_seconds*FPS))

  __pyx_t_10 = __pyx_v_max_ship_range_test;
  __Pyx_INCREF(__pyx_t_10);
  __pyx_t_3 = NULL;
  __Pyx_INCREF(__pyx_builtin_round);
  __pyx_t_7 = __pyx_builtin_round; 
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_max_cruise_seconds); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3090, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3090, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3090, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_9 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
    __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3090, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
  }
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_8};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_cruise, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3090, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3091:     max_ship_range_test.accelerate(0)

  __pyx_t_8 = __pyx_v_max_ship_range_test;
  __Pyx_INCREF(__pyx_t_8);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_accelerate, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3091, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3092:     state_sequence = max_ship_range_test.get_state_sequence()

  __pyx_t_8 = __pyx_v_max_ship_range_test;
  __Pyx_INCREF(__pyx_t_8);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_state_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3092, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_state_sequence = __pyx_t_1;
  __pyx_t_1 = 0;

+3093:     ship_random_range = dist(state_sequence[0].ship_state.position, state_sequence[-1].ship_state.position)

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_dist); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_state_sequence, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_state_sequence, -1L, long, 1, __Pyx_PyLong_From_long, 0, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3093, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3093, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_ship_random_range = __pyx_t_1;
  __pyx_t_1 = 0;

+3094:     ship_random_max_maneuver_length = len(state_sequence)

  __pyx_t_11 = PyObject_Length(__pyx_v_state_sequence); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3094, __pyx_L1_error)
  __pyx_v_ship_random_max_maneuver_length = __pyx_t_11;

+3095:     return ship_random_range, ship_random_max_maneuver_length

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_ship_random_max_maneuver_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3095, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3095, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_INCREF(__pyx_v_ship_random_range);
  __Pyx_GIVEREF(__pyx_v_ship_random_range);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_ship_random_range) != (0)) __PYX_ERR(0, 3095, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 3095, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_r = ((PyObject*)__pyx_t_10);
  __pyx_t_10 = 0;
  goto __pyx_L0;

 3096: 

 3097: 

+3098: def simulate_ship_movement_with_inputs(game_state: GameState, ship_state: Ship, move_sequence: list[Action]) -> Ship:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_Ship *__pyx_pw_14neo_controller_133simulate_ship_movement_with_inputs(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_133simulate_ship_movement_with_inputs = {"simulate_ship_movement_with_inputs", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_133simulate_ship_movement_with_inputs, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static struct __pyx_obj_14neo_controller_Ship *__pyx_pw_14neo_controller_133simulate_ship_movement_with_inputs(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  PyObject *__pyx_v_move_sequence = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_Ship *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("simulate_ship_movement_with_inputs (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_move_sequence,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3098, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3098, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3098, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3098, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "simulate_ship_movement_with_inputs", 0) < 0) __PYX_ERR(0, 3098, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("simulate_ship_movement_with_inputs", 1, 3, 3, i); __PYX_ERR(0, 3098, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3098, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3098, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3098, __pyx_L3_error)
    }
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[0]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[1]);
    __pyx_v_move_sequence = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("simulate_ship_movement_with_inputs", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3098, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.simulate_ship_movement_with_inputs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3098, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 3098, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_move_sequence), (&PyList_Type), 0, "move_sequence", 2))) __PYX_ERR(0, 3098, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_132simulate_ship_movement_with_inputs(__pyx_self, __pyx_v_game_state, __pyx_v_ship_state, __pyx_v_move_sequence);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_Ship *__pyx_pf_14neo_controller_132simulate_ship_movement_with_inputs(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state, PyObject *__pyx_v_move_sequence) {
  PyObject *__pyx_v_dummy_game_state = NULL;
  PyObject *__pyx_v_ship_movement_sim = NULL;
  struct __pyx_obj_14neo_controller_Ship *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.simulate_ship_movement_with_inputs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_dummy_game_state);
  __Pyx_XDECREF(__pyx_v_ship_movement_sim);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3098, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3098, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 3098, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_move_sequence, __pyx_mstate_global->__pyx_kp_u_list_Action) < 0) __PYX_ERR(0, 3098, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 3098, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_133simulate_ship_movement_with_inputs, 0, __pyx_mstate_global->__pyx_n_u_simulate_ship_movement_with_inpu, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[139])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3098, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_simulate_ship_movement_with_inpu, __pyx_t_4) < 0) __PYX_ERR(0, 3098, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 3099:     # UNUSED

 3100:     # TODO: Replace cast with GameState instantiation

+3101:     dummy_game_state = cast(GameState, {'asteroids': [], 'ships': [], 'bullets': [], 'mines': [], 'map_size': game_state.map_size, 'time': 0.0, 'delta_time': 1/30, 'sim_frame': 0})

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyDict_NewPresized(8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_5) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ships, __pyx_t_5) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_5) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_mines, __pyx_t_5) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_map_size, __pyx_t_5) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_time, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __pyx_t_5 = PyFloat_FromDouble((1.0 / 30.0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_delta_time, __pyx_t_5) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sim_frame, __pyx_mstate_global->__pyx_int_0) < 0) __PYX_ERR(0, 3101, __pyx_L1_error)
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState), __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3101, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_dummy_game_state = __pyx_t_1;
  __pyx_t_1 = 0;

+3102:     ship_movement_sim = Matrix(dummy_game_state, ship_state, 0, 0.0)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3102, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[5] = {__pyx_t_3, __pyx_v_dummy_game_state, ((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_float_0_0};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3102, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_ship_movement_sim = __pyx_t_1;
  __pyx_t_1 = 0;

+3103:     ship_movement_sim.apply_move_sequence(move_sequence)

  __pyx_t_4 = __pyx_v_ship_movement_sim;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_move_sequence};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_apply_move_sequence, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3103, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3104:     return ship_movement_sim.get_ship_state()

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __pyx_t_4 = __pyx_v_ship_movement_sim;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_ship_state, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3104, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship))))) __PYX_ERR(0, 3104, __pyx_L1_error)
  __pyx_r = ((struct __pyx_obj_14neo_controller_Ship *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3105: 

 3106: 

+3107: def get_adversary_interception_time_lower_bound(asteroid: Asteroid, adversary_ships: list[Ship], game_state: GameState, adversary_rotation_timestep_fudge: int = ADVERSARY_ROTATION_TIMESTEP_FUDGE) -> float:

static PyObject *__pyx_pf_14neo_controller_157__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 3107, __pyx_L1_error);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 3107, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 3107, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_135get_adversary_interception_time_lower_bound(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_135get_adversary_interception_time_lower_bound = {"get_adversary_interception_time_lower_bound", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_135get_adversary_interception_time_lower_bound, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_135get_adversary_interception_time_lower_bound(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  PyObject *__pyx_v_adversary_ships = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  PyObject *__pyx_v_adversary_rotation_timestep_fudge = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_adversary_interception_time_lower_bound (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_adversary_ships,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_adversary_rotation_timestep_fudg,0};
  PyObject* values[4] = {0,0,0,0};
    struct __pyx_defaults1 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self);
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3107, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_adversary_interception_time_lower_bound", 0) < 0) __PYX_ERR(0, 3107, __pyx_L3_error)
      if (!values[3]) values[3] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_adversary_interception_time_lower_bound", 0, 3, 4, i); __PYX_ERR(0, 3107, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3107, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3107, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3107, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3107, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[3]) values[3] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_adversary_ships = ((PyObject*)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
    __pyx_v_adversary_rotation_timestep_fudge = ((PyObject*)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_adversary_interception_time_lower_bound", 0, 3, 4, __pyx_nargs); __PYX_ERR(0, 3107, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.get_adversary_interception_time_lower_bound", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 3107, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_adversary_ships), (&PyList_Type), 0, "adversary_ships", 2))) __PYX_ERR(0, 3107, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3107, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_adversary_rotation_timestep_fudge), (&PyLong_Type), 0, "adversary_rotation_timestep_fudge", 2))) __PYX_ERR(0, 3107, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_134get_adversary_interception_time_lower_bound(__pyx_self, __pyx_v_asteroid, __pyx_v_adversary_ships, __pyx_v_game_state, __pyx_v_adversary_rotation_timestep_fudge);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_134get_adversary_interception_time_lower_bound(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, PyObject *__pyx_v_adversary_ships, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, PyObject *__pyx_v_adversary_rotation_timestep_fudge) {
  PyObject *__pyx_v_feasible = NULL;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_v_aiming_timesteps_required = NULL;
  PyObject *__pyx_v_interception_time_s = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("neo_controller.get_adversary_interception_time_lower_bound", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_feasible);
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XDECREF(__pyx_v_aiming_timesteps_required);
  __Pyx_XDECREF(__pyx_v_interception_time_s);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3107, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_adversary_ships, __pyx_mstate_global->__pyx_kp_u_list_Ship) < 0) __PYX_ERR(0, 3107, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3107, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_adversary_rotation_timestep_fudg, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3107, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3107, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_135get_adversary_interception_time_lower_bound, 0, __pyx_mstate_global->__pyx_n_u_get_adversary_interception_time, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[140])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_defaults1)) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ADVERSARY_ROTATION_TIMESTEP_FUDG); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (!(likely(PyLong_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_3))) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_t_2)->arg0 = ((PyObject*)__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_3);
  __pyx_t_3 = 0;
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_2, __pyx_pf_14neo_controller_157__defaults__);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_adversary_interception_time, __pyx_t_2) < 0) __PYX_ERR(0, 3107, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_defaults1 {
  PyObject_HEAD
  PyObject *arg0;
};

+3108:     if not adversary_ships:

  __pyx_t_1 = (__Pyx_PyList_GET_SIZE(__pyx_v_adversary_ships) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 3108, __pyx_L1_error)
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+3109:         return INFINITY

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3109, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_r = __pyx_t_3;
    __pyx_t_3 = 0;
    goto __pyx_L0;

 3110:     # The interception time is just from firing to hitting. It doesn't include the aiming time!

+3111:     feasible, _, aiming_timesteps_required, interception_time_s, _, _, _ = solve_interception(asteroid, adversary_ships[0], game_state, 0)

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_solve_interception); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[5] = {__pyx_t_4, ((PyObject *)__pyx_v_asteroid), __Pyx_PyList_GET_ITEM(__pyx_v_adversary_ships, 0), ((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_int_0};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3111, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
    PyObject* sequence = __pyx_t_3;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 7)) {
      if (size > 7) __Pyx_RaiseTooManyValuesError(7);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 3111, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_7 = PyTuple_GET_ITEM(sequence, 2);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 3);
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 4);
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_10 = PyTuple_GET_ITEM(sequence, 5);
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_11 = PyTuple_GET_ITEM(sequence, 6);
      __Pyx_INCREF(__pyx_t_11);
    } else {
      __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3111, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3111, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_4);
      __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 2);
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3111, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_7);
      __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 3);
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3111, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_8);
      __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 4);
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3111, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_9);
      __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 5);
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3111, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_11 = __Pyx_PyList_GetItemRef(sequence, 6);
      if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3111, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_11);
    }
    #else
    {
      Py_ssize_t i;
      PyObject** temps[7] = {&__pyx_t_5,&__pyx_t_4,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11};
      for (i=0; i < 7; i++) {
        PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 3111, __pyx_L1_error)
        __Pyx_GOTREF(item);
        *(temps[i]) = item;
      }
    }
    #endif
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  } else {
    Py_ssize_t index = -1;
    PyObject** temps[7] = {&__pyx_t_5,&__pyx_t_4,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11};
    __pyx_t_12 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3111, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_12);
    for (index=0; index < 7; index++) {
      PyObject* item = __pyx_t_13(__pyx_t_12); if (unlikely(!item)) goto __pyx_L4_unpacking_failed;
      __Pyx_GOTREF(item);
      *(temps[index]) = item;
    }
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_13(__pyx_t_12), 7) < 0) __PYX_ERR(0, 3111, __pyx_L1_error)
    __pyx_t_13 = NULL;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    goto __pyx_L5_unpacking_done;
    __pyx_L4_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_13 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 3111, __pyx_L1_error)
    __pyx_L5_unpacking_done:;
  }
  __pyx_v_feasible = __pyx_t_5;
  __pyx_t_5 = 0;
  __pyx_v__ = __pyx_t_4;
  __pyx_t_4 = 0;
  __pyx_v_aiming_timesteps_required = __pyx_t_7;
  __pyx_t_7 = 0;
  __pyx_v_interception_time_s = __pyx_t_8;
  __pyx_t_8 = 0;
  __Pyx_DECREF_SET(__pyx_v__, __pyx_t_9);
  __pyx_t_9 = 0;
  __Pyx_DECREF_SET(__pyx_v__, __pyx_t_10);
  __pyx_t_10 = 0;
  __Pyx_DECREF_SET(__pyx_v__, __pyx_t_11);
  __pyx_t_11 = 0;

+3112:     if feasible:

  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_feasible); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3112, __pyx_L1_error)
  if (__pyx_t_2) {
/* … */
  }

+3113:         return max(0.0, interception_time_s + float(aiming_timesteps_required - adversary_rotation_timestep_fudge)*DELTA_TIME)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = PyNumber_Subtract(__pyx_v_aiming_timesteps_required, __pyx_v_adversary_rotation_timestep_fudge); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_11 = __Pyx_PyNumber_Float(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_10 = PyNumber_Multiply(__pyx_t_11, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Add(__pyx_v_interception_time_s, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_14 = 0.0;
    __pyx_t_11 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_9 = PyObject_RichCompare(__pyx_t_3, __pyx_t_11, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3113, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_2) {
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_10 = __pyx_t_3;
    } else {
      __pyx_t_9 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3113, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = __pyx_t_9;
      __pyx_t_9 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_INCREF(__pyx_t_10);
    __pyx_r = __pyx_t_10;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    goto __pyx_L0;

 3114:     else:

+3115:         return INFINITY

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_10 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3115, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_r = __pyx_t_10;
    __pyx_t_10 = 0;
    goto __pyx_L0;
  }

 3116: 

 3117: 

+3118: def solve_interception(asteroid: Asteroid, ship_state: Ship, game_state: GameState, timesteps_until_can_fire: int = 0) -> tuple[bool, float, int, float, float, float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_137solve_interception(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_137solve_interception = {"solve_interception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_137solve_interception, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_137solve_interception(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  PyObject *__pyx_v_timesteps_until_can_fire = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solve_interception (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_timesteps_until_can_fire,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3118, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3118, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3118, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3118, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3118, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "solve_interception", 0) < 0) __PYX_ERR(0, 3118, __pyx_L3_error)
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("solve_interception", 0, 3, 4, i); __PYX_ERR(0, 3118, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3118, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3118, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3118, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3118, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
    __pyx_v_timesteps_until_can_fire = ((PyObject*)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("solve_interception", 0, 3, 4, __pyx_nargs); __PYX_ERR(0, 3118, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 3118, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 3118, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3118, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timesteps_until_can_fire), (&PyLong_Type), 0, "timesteps_until_can_fire", 2))) __PYX_ERR(0, 3118, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_136solve_interception(__pyx_self, __pyx_v_asteroid, __pyx_v_ship_state, __pyx_v_game_state, __pyx_v_timesteps_until_can_fire);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_136solve_interception(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, PyObject *__pyx_v_timesteps_until_can_fire) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  __pyx_ctuple_double__and_double __pyx_v_asteroid_velocity;
  __pyx_ctuple_double__and_double __pyx_v_asteroid_position;
  PyObject *__pyx_v_bullet_travel_time = 0;
  CYTHON_UNUSED PyObject *__pyx_v_plot_function = 0;
  PyObject *__pyx_v_amount_we_can_turn_before_we_can_shoot_rad = NULL;
  PyObject *__pyx_v_naive_solution = NULL;
  PyObject *__pyx_v_delta_theta_solution = NULL;
  PyObject *__pyx_v_absolute_theta_solution = NULL;
  PyObject *__pyx_v_delta_theta_solution_deg = NULL;
  PyObject *__pyx_v_t_rot = NULL;
  PyObject *__pyx_v_t_bullet = NULL;
  PyObject *__pyx_v_bullet_travel_dist = NULL;
  PyObject *__pyx_v_intercept_x = NULL;
  PyObject *__pyx_v_intercept_y = NULL;
  PyObject *__pyx_v_t_rot_ts = NULL;
  PyObject *__pyx_v_discrete_solution = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *)__pyx_tp_new_14neo_controller___pyx_scope_struct_10_solve_interception(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_10_solve_interception, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 3118, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_ship_state = __pyx_v_ship_state;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_ship_state);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_ship_state);
  __pyx_cur_scope->__pyx_v_timesteps_until_can_fire = __pyx_v_timesteps_until_can_fire;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_AddTraceback("neo_controller.solve_interception", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_bullet_travel_time);
  __Pyx_XDECREF(__pyx_v_plot_function);
  __Pyx_XDECREF(__pyx_v_amount_we_can_turn_before_we_can_shoot_rad);
  __Pyx_XDECREF(__pyx_v_naive_solution);
  __Pyx_XDECREF(__pyx_v_delta_theta_solution);
  __Pyx_XDECREF(__pyx_v_absolute_theta_solution);
  __Pyx_XDECREF(__pyx_v_delta_theta_solution_deg);
  __Pyx_XDECREF(__pyx_v_t_rot);
  __Pyx_XDECREF(__pyx_v_t_bullet);
  __Pyx_XDECREF(__pyx_v_bullet_travel_dist);
  __Pyx_XDECREF(__pyx_v_intercept_x);
  __Pyx_XDECREF(__pyx_v_intercept_y);
  __Pyx_XDECREF(__pyx_v_t_rot_ts);
  __Pyx_XDECREF(__pyx_v_discrete_solution);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3118, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 3118, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3118, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_timesteps_until_can_fire, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3118, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_bool_float_int_float_float) < 0) __PYX_ERR(0, 3118, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_137solve_interception, 0, __pyx_mstate_global->__pyx_n_u_solve_interception, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[141])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[18]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_solve_interception, __pyx_t_4) < 0) __PYX_ERR(0, 3118, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception {
  PyObject_HEAD
  PyObject *__pyx_v_a;
  double __pyx_v_avx;
  double __pyx_v_avy;
  double __pyx_v_ax;
  double __pyx_v_ay;
  PyObject *__pyx_v_bullet_travel_time_for_plot;
  PyObject *__pyx_v_k1;
  PyObject *__pyx_v_k2;
  double __pyx_v_k3;
  PyObject *__pyx_v_naive_desired_heading_calc;
  PyObject *__pyx_v_naive_root_function;
  PyObject *__pyx_v_naive_time_function;
  PyObject *__pyx_v_naive_time_function_for_plotting;
  double __pyx_v_origin_x;
  double __pyx_v_origin_y;
  PyObject *__pyx_v_root_function;
  PyObject *__pyx_v_root_function_derivative;
  PyObject *__pyx_v_root_function_second_derivative;
  PyObject *__pyx_v_rotation_time;
  __pyx_ctuple_double__and_double __pyx_v_ship_position;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state;
  double __pyx_v_t_0;
  PyObject *__pyx_v_theta_0;
  PyObject *__pyx_v_timesteps_until_can_fire;
  PyObject *__pyx_v_turbo_rootinator_5000;
  PyObject *__pyx_v_vb;
  PyObject *__pyx_v_vb_sq;
};

 3119:     # The bullet's head originates from the edge of the ship's radius.

 3120:     # We want to set the position of the bullet to the center of the bullet, so we have to do some fanciness here so that at t=0, the bullet's center is where it should be

+3121:     t_0 = 0.0175 # t_0 = (SHIP_RADIUS - 0.5*BULLET_LENGTH)/BULLET_SPEED

  __pyx_cur_scope->__pyx_v_t_0 = 0.0175;

 3122:     # Positions are relative to the ship. We set the origin to the ship's position. Remember to translate back!

+3123:     asteroid_velocity: tuple[float, float] = asteroid.velocity

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3123, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_convert__from_py___pyx_ctuple_double__and_double(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3123, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_asteroid_velocity = __pyx_t_2;

+3124:     asteroid_position: tuple[float, float] = asteroid.position

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_convert__from_py___pyx_ctuple_double__and_double(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3124, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_asteroid_position = __pyx_t_2;

+3125:     ship_position: tuple[float, float] = ship_state.position

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3125, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_convert__from_py___pyx_ctuple_double__and_double(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3125, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_cur_scope->__pyx_v_ship_position = __pyx_t_2;

+3126:     origin_x: float = ship_position[0]

  __pyx_cur_scope->__pyx_v_origin_x = __pyx_cur_scope->__pyx_v_ship_position.f0;

+3127:     origin_y: float = ship_position[1]

  __pyx_cur_scope->__pyx_v_origin_y = __pyx_cur_scope->__pyx_v_ship_position.f1;

+3128:     avx: float = asteroid_velocity[0]

  __pyx_cur_scope->__pyx_v_avx = __pyx_v_asteroid_velocity.f0;

+3129:     avy: float = asteroid_velocity[1]

  __pyx_cur_scope->__pyx_v_avy = __pyx_v_asteroid_velocity.f1;

+3130:     ax: float = asteroid_position[0] - origin_x + avx*DELTA_TIME  # We project the asteroid one timestep ahead, since by the time we shoot our bullet, the asteroid would have moved one more timestep!

  __pyx_t_1 = PyFloat_FromDouble((__pyx_v_asteroid_position.f0 - __pyx_cur_scope->__pyx_v_origin_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_cur_scope->__pyx_v_ax = __pyx_t_6;

+3131:     ay: float = asteroid_position[1] - origin_y + avy*DELTA_TIME

  __pyx_t_4 = PyFloat_FromDouble((__pyx_v_asteroid_position.f1 - __pyx_cur_scope->__pyx_v_origin_y)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3131, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_cur_scope->__pyx_v_ay = __pyx_t_6;

 3132: 

+3133:     vb = BULLET_SPEED

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_vb = __pyx_t_1;
  __pyx_t_1 = 0;

+3134:     vb_sq = vb*vb

  __pyx_t_1 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_cur_scope->__pyx_v_vb); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_vb_sq = __pyx_t_1;
  __pyx_t_1 = 0;

+3135:     theta_0 = radians(ship_state.heading)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ship_state->heading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3135, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_theta_0 = __pyx_t_1;
  __pyx_t_1 = 0;

 3136: 

 3137:     # Calculate constants for naive_desired_heading_calc

+3138:     a = avx*avx + avy*avy - vb_sq

  __pyx_t_1 = PyFloat_FromDouble(((__pyx_cur_scope->__pyx_v_avx * __pyx_cur_scope->__pyx_v_avx) + (__pyx_cur_scope->__pyx_v_avy * __pyx_cur_scope->__pyx_v_avy))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3138, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_1, __pyx_cur_scope->__pyx_v_vb_sq); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3138, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_cur_scope->__pyx_v_a = __pyx_t_4;
  __pyx_t_4 = 0;

 3139: 

 3140:     # Calculate constants for root_function, root_function_derivative, root_function_second_derivative

+3141:     k1 = ay*vb - avy*vb*t_0

  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ay); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_4, __pyx_cur_scope->__pyx_v_vb); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_cur_scope->__pyx_v_vb); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_cur_scope->__pyx_v_k1 = __pyx_t_4;
  __pyx_t_4 = 0;

+3142:     k2 = ax*vb - avx*vb*t_0

  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_4, __pyx_cur_scope->__pyx_v_vb); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_4, __pyx_cur_scope->__pyx_v_vb); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_cur_scope->__pyx_v_k2 = __pyx_t_4;
  __pyx_t_4 = 0;

+3143:     k3 = avy*ax - avx*ay

  __pyx_cur_scope->__pyx_v_k3 = ((__pyx_cur_scope->__pyx_v_avy * __pyx_cur_scope->__pyx_v_ax) - (__pyx_cur_scope->__pyx_v_avx * __pyx_cur_scope->__pyx_v_ay));

 3144: 

+3145:     def naive_desired_heading_calc(timesteps_until_fire: int = 0) -> tuple[float, float, int, float, float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_1naive_desired_heading_calc(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_1naive_desired_heading_calc = {"naive_desired_heading_calc", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_1naive_desired_heading_calc, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_1naive_desired_heading_calc(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_timesteps_until_fire = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("naive_desired_heading_calc (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_timesteps_until_fire,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3145, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3145, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "naive_desired_heading_calc", 0) < 0) __PYX_ERR(0, 3145, __pyx_L3_error)
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
    } else {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3145, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[0]) values[0] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
    }
    __pyx_v_timesteps_until_fire = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("naive_desired_heading_calc", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 3145, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_desired_heading_calc", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timesteps_until_fire), (&PyLong_Type), 0, "timesteps_until_fire", 2))) __PYX_ERR(0, 3145, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_naive_desired_heading_calc(__pyx_self, __pyx_v_timesteps_until_fire);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_naive_desired_heading_calc(PyObject *__pyx_self, PyObject *__pyx_v_timesteps_until_fire) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  PyObject *__pyx_v_time_until_can_fire_s = NULL;
  PyObject *__pyx_v_ax_delayed = NULL;
  PyObject *__pyx_v_ay_delayed = NULL;
  PyObject *__pyx_v_b = NULL;
  PyObject *__pyx_v_c = NULL;
  PyObject *__pyx_v_t = NULL;
  PyObject *__pyx_v_x = NULL;
  PyObject *__pyx_v_y = NULL;
  PyObject *__pyx_v_theta = NULL;
  PyObject *__pyx_v_intercept_x = NULL;
  PyObject *__pyx_v_intercept_y = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_desired_heading_calc", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_time_until_can_fire_s);
  __Pyx_XDECREF(__pyx_v_ax_delayed);
  __Pyx_XDECREF(__pyx_v_ay_delayed);
  __Pyx_XDECREF(__pyx_v_b);
  __Pyx_XDECREF(__pyx_v_c);
  __Pyx_XDECREF(__pyx_v_t);
  __Pyx_XDECREF(__pyx_v_x);
  __Pyx_XDECREF(__pyx_v_y);
  __Pyx_XDECREF(__pyx_v_theta);
  __Pyx_XDECREF(__pyx_v_intercept_x);
  __Pyx_XDECREF(__pyx_v_intercept_y);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_timesteps_until_fire, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3145, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float_int_float_floa) < 0) __PYX_ERR(0, 3145, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_1naive_desired_heading_calc, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_naive, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[18]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GIVEREF(__pyx_t_5);
  __pyx_cur_scope->__pyx_v_naive_desired_heading_calc = __pyx_t_5;
  __pyx_t_5 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[18] = PyTuple_Pack(1, ((PyObject*)__pyx_mstate_global->__pyx_int_0)); if (unlikely(!__pyx_mstate_global->__pyx_tuple[18])) __PYX_ERR(0, 3145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[18]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[18]);

 3146:         # Here's a good resource to learn about this: https://www.youtube.com/watch?v=MpUUsDDE1sI

 3147:         # https://medium.com/andys-coding-blog/ai-projectile-intercept-formula-for-gaming-without-trigonometry-37b70ef5718b

+3148:         time_until_can_fire_s = float(timesteps_until_fire)*DELTA_TIME

  __pyx_t_1 = PyLong_AsDouble(__pyx_v_timesteps_until_fire); if (unlikely(__pyx_t_1 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3148, __pyx_L1_error)
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_time_until_can_fire_s = __pyx_t_4;
  __pyx_t_4 = 0;

+3149:         ax_delayed = ax + time_until_can_fire_s*avx  # We add a delay to account for the timesteps until we fire delay

  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3149, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3149, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyNumber_Multiply(__pyx_v_time_until_can_fire_s, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3149, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3149, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_ax_delayed = __pyx_t_3;
  __pyx_t_3 = 0;

+3150:         ay_delayed = ay + time_until_can_fire_s*avy

  __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ay); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyNumber_Multiply(__pyx_v_time_until_can_fire_s, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_ay_delayed = __pyx_t_2;
  __pyx_t_2 = 0;

 3151: 

 3152:         # a is calculated outside of this function since it's a constant

+3153:         b = 2.0*(ax_delayed*avx + ay_delayed*avy - vb_sq*t_0)

  __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyNumber_Multiply(__pyx_v_ax_delayed, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Multiply(__pyx_v_ay_delayed, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb_sq)) { __Pyx_RaiseClosureNameError("vb_sq"); __PYX_ERR(0, 3153, __pyx_L1_error) }
  __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb_sq, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_2_0, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_b = __pyx_t_4;
  __pyx_t_4 = 0;

+3154:         c = ax_delayed*ax_delayed + ay_delayed*ay_delayed - vb_sq*t_0*t_0

  __pyx_t_4 = PyNumber_Multiply(__pyx_v_ax_delayed, __pyx_v_ax_delayed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyNumber_Multiply(__pyx_v_ay_delayed, __pyx_v_ay_delayed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb_sq)) { __Pyx_RaiseClosureNameError("vb_sq"); __PYX_ERR(0, 3154, __pyx_L1_error) }
  __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb_sq, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_c = __pyx_t_3;
  __pyx_t_3 = 0;

 3155: 

 3156:         #solutions = []

+3157:         for t in solve_quadratic(a, b, c):

  __pyx_t_5 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_solve_quadratic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3157, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely(!__pyx_cur_scope->__pyx_v_a)) { __Pyx_RaiseClosureNameError("a"); __PYX_ERR(0, 3157, __pyx_L1_error) }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_5);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_a, __pyx_v_b, __pyx_v_c};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
    __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_7 = 0;
    __pyx_t_8 = NULL;
  } else {
    __pyx_t_7 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3157, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  for (;;) {
    if (likely(!__pyx_t_8)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3157, __pyx_L1_error)
          #endif
          if (__pyx_t_7 >= __pyx_temp) break;
        }
        __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_7);
        ++__pyx_t_7;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3157, __pyx_L1_error)
          #endif
          if (__pyx_t_7 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_7));
        #else
        __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_7);
        #endif
        ++__pyx_t_7;
      }
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3157, __pyx_L1_error)
    } else {
      __pyx_t_3 = __pyx_t_8(__pyx_t_2);
      if (unlikely(!__pyx_t_3)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3157, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
    __pyx_L3_continue:;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3158:             if isnan(t) or t < 0.0:

    __pyx_t_10 = __Pyx_PyFloat_AsDouble(__pyx_v_t); if (unlikely((__pyx_t_10 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3158, __pyx_L1_error)
    __pyx_t_11 = isnan(__pyx_t_10);
    if (!__pyx_t_11) {
    } else {
      __pyx_t_9 = __pyx_t_11;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3158, __pyx_L1_error)
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 3158, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_9 = __pyx_t_11;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_9) {
/* … */
    }

+3159:                 continue

      goto __pyx_L3_continue;

+3160:             x = ax_delayed + t*avx

    __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyNumber_Multiply(__pyx_v_t, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Add(__pyx_v_ax_delayed, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_v_x = __pyx_t_3;
    __pyx_t_3 = 0;

+3161:             y = ay_delayed + t*avy

    __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3161, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyNumber_Multiply(__pyx_v_t, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3161, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Add(__pyx_v_ay_delayed, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3161, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_v_y = __pyx_t_3;
    __pyx_t_3 = 0;

+3162:             theta = fast_atan2(y, x)

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_fast_atan2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_y, __pyx_v_x};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3162, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_v_theta = __pyx_t_3;
    __pyx_t_3 = 0;

 3163:             # If the asteroid is out of bounds, then it will wrap around and this shot isn't feasible

 3164:             # However, if an unwrapped asteroid was passed into this function and the interception is inbounds, then it's a feasible shot

+3165:             intercept_x = x + origin_x

    __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_origin_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3165, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyNumber_Add(__pyx_v_x, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3165, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_intercept_x = __pyx_t_4;
    __pyx_t_4 = 0;

+3166:             intercept_y = y + origin_y

    __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_origin_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3166, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyNumber_Add(__pyx_v_y, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3166, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_intercept_y = __pyx_t_3;
    __pyx_t_3 = 0;

 3167:             # Return the first answer we get

+3168:             return t, angle_difference_rad(theta, theta_0), timesteps_until_fire, intercept_x, intercept_y, dist(ship_position, (intercept_x, intercept_y))

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_angle_difference_rad); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3168, __pyx_L1_error) }
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_theta, __pyx_cur_scope->__pyx_v_theta_0};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3168, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_dist); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_13 = __pyx_convert__to_py___pyx_ctuple_double__and_double(__pyx_cur_scope->__pyx_v_ship_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __Pyx_INCREF(__pyx_v_intercept_x);
    __Pyx_GIVEREF(__pyx_v_intercept_x);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_v_intercept_x) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_intercept_y);
    __Pyx_GIVEREF(__pyx_v_intercept_y);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_v_intercept_y) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_12))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_12);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_13, __pyx_t_14};
      __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3168, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_12 = PyTuple_New(6); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_INCREF(__pyx_v_t);
    __Pyx_GIVEREF(__pyx_v_t);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_v_t) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_timesteps_until_fire);
    __Pyx_GIVEREF(__pyx_v_timesteps_until_fire);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_v_timesteps_until_fire) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_intercept_x);
    __Pyx_GIVEREF(__pyx_v_intercept_x);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 3, __pyx_v_intercept_x) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __Pyx_INCREF(__pyx_v_intercept_y);
    __Pyx_GIVEREF(__pyx_v_intercept_y);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 4, __pyx_v_intercept_y) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_5);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 5, __pyx_t_5) != (0)) __PYX_ERR(0, 3168, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_t_5 = 0;
    __pyx_r = ((PyObject*)__pyx_t_12);
    __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    goto __pyx_L0;

 3169:         #if len(solutions) > 1:

 3170:         #    print(len(solutions))

 3171:         #return solutions

+3172:         return NAN, NAN, 0, NAN, NAN, NAN

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_12 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_5 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_14 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_14);
  __pyx_t_13 = PyTuple_New(6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 3172, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 3172, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 3172, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 3, __pyx_t_5) != (0)) __PYX_ERR(0, 3172, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 4, __pyx_t_3) != (0)) __PYX_ERR(0, 3172, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_14);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 5, __pyx_t_14) != (0)) __PYX_ERR(0, 3172, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_t_12 = 0;
  __pyx_t_5 = 0;
  __pyx_t_3 = 0;
  __pyx_t_14 = 0;
  __pyx_r = ((PyObject*)__pyx_t_13);
  __pyx_t_13 = 0;
  goto __pyx_L0;

 3173:         # Returned tuple is (interception time in seconds from firing to hit, delta theta rad, timesteps until fire, None, intercept_x, intercept_y, dist)

 3174: 

+3175:     def naive_root_function(theta: float, time_until_can_fire_s: float = 0.0) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_3naive_root_function(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_3naive_root_function = {"naive_root_function", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_3naive_root_function, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_3naive_root_function(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  double __pyx_v_time_until_can_fire_s;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("naive_root_function (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,&__pyx_mstate_global->__pyx_n_u_time_until_can_fire_s,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3175, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3175, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3175, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "naive_root_function", 0) < 0) __PYX_ERR(0, 3175, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("naive_root_function", 0, 1, 2, i); __PYX_ERR(0, 3175, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3175, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3175, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3175, __pyx_L3_error)
    if (values[1]) {
      __pyx_v_time_until_can_fire_s = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_time_until_can_fire_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3175, __pyx_L3_error)
    } else {
      __pyx_v_time_until_can_fire_s = ((double)((double)0.0));
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("naive_root_function", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3175, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_root_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_2naive_root_function(__pyx_self, __pyx_v_theta, __pyx_v_time_until_can_fire_s);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_2naive_root_function(PyObject *__pyx_self, double __pyx_v_theta, double __pyx_v_time_until_can_fire_s) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  double __pyx_v_cos_theta;
  double __pyx_v_sin_theta;
  double __pyx_v_ax_delayed;
  double __pyx_v_ay_delayed;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_root_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 3175, __pyx_L1_error);
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3175, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_time_until_can_fire_s, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3175, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3175, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_3naive_root_function, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_naive_2, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GIVEREF(__pyx_t_3);
  __pyx_cur_scope->__pyx_v_naive_root_function = __pyx_t_3;
  __pyx_t_3 = 0;

 3176:         # Can be optimized more by expanding out the terms

 3177:         # Convert heading error to absolute heading

+3178:         theta += theta_0

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3178, __pyx_L1_error) }
  __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3178, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_theta = __pyx_t_3;

+3179:         cos_theta = cos(theta)

  __pyx_v_cos_theta = cos(__pyx_v_theta);

+3180:         sin_theta = sin(theta)

  __pyx_v_sin_theta = sin(__pyx_v_theta);

+3181:         ax_delayed = ax + time_until_can_fire_s*avx  # We add a delay to account for the timesteps until we can fire delay

  __pyx_v_ax_delayed = (__pyx_cur_scope->__pyx_v_ax + (__pyx_v_time_until_can_fire_s * __pyx_cur_scope->__pyx_v_avx));

+3182:         ay_delayed = ay + time_until_can_fire_s*avy

  __pyx_v_ay_delayed = (__pyx_cur_scope->__pyx_v_ay + (__pyx_v_time_until_can_fire_s * __pyx_cur_scope->__pyx_v_avy));

+3183:         return (vb*cos_theta - avx)*(ay_delayed - vb*t_0*sin_theta) - (vb*sin_theta - avy)*(ax_delayed - vb*t_0*cos_theta)

  __Pyx_XDECREF(__pyx_r);
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3183, __pyx_L1_error) }
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_ay_delayed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3183, __pyx_L1_error) }
  __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3183, __pyx_L1_error) }
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_ax_delayed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3183, __pyx_L1_error) }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_1, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 3184: 

+3185:     def naive_time_function(theta: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_5naive_time_function(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_5naive_time_function = {"naive_time_function", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_5naive_time_function, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_5naive_time_function(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("naive_time_function (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3185, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3185, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "naive_time_function", 0) < 0) __PYX_ERR(0, 3185, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("naive_time_function", 1, 1, 1, i); __PYX_ERR(0, 3185, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3185, __pyx_L3_error)
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3185, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("naive_time_function", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3185, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_time_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_4naive_time_function(__pyx_self, __pyx_v_theta);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_4naive_time_function(PyObject *__pyx_self, double __pyx_v_theta) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  double __pyx_v_cos_theta;
  double __pyx_v_sin_theta;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_time_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3185, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3185, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_5naive_time_function, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_naive_3, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GIVEREF(__pyx_t_5);
  __pyx_cur_scope->__pyx_v_naive_time_function = __pyx_t_5;
  __pyx_t_5 = 0;

 3186:         # UNUSED

 3187:         # Convert heading error to absolute heading

+3188:         theta += theta_0

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3188, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3188, __pyx_L1_error) }
  __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3188, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3188, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_theta = __pyx_t_3;

+3189:         cos_theta = cos(theta)

  __pyx_v_cos_theta = cos(__pyx_v_theta);

+3190:         sin_theta = sin(theta)

  __pyx_v_sin_theta = sin(__pyx_v_theta);

+3191:         return (ax + ay - vb*t_0*(sin_theta + cos_theta))/(vb*(sin_theta + cos_theta) - avx - avy)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble((__pyx_cur_scope->__pyx_v_ax + __pyx_cur_scope->__pyx_v_ay)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3191, __pyx_L1_error) }
  __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble((__pyx_v_sin_theta + __pyx_v_cos_theta)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3191, __pyx_L1_error) }
  __pyx_t_5 = PyFloat_FromDouble((__pyx_v_sin_theta + __pyx_v_cos_theta)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

 3192: 

+3193:     def naive_time_function_for_plotting(theta: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_7naive_time_function_for_plotting(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_7naive_time_function_for_plotting = {"naive_time_function_for_plotting", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_7naive_time_function_for_plotting, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_7naive_time_function_for_plotting(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("naive_time_function_for_plotting (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3193, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3193, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "naive_time_function_for_plotting", 0) < 0) __PYX_ERR(0, 3193, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("naive_time_function_for_plotting", 1, 1, 1, i); __PYX_ERR(0, 3193, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3193, __pyx_L3_error)
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3193, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("naive_time_function_for_plotting", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3193, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_time_function_for_plotting", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_6naive_time_function_for_plotting(__pyx_self, __pyx_v_theta);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_6naive_time_function_for_plotting(PyObject *__pyx_self, double __pyx_v_theta) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.solve_interception.naive_time_function_for_plotting", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3193, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3193, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_7naive_time_function_for_plotting, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_naive_4, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GIVEREF(__pyx_t_3);
  __pyx_cur_scope->__pyx_v_naive_time_function_for_plotting = __pyx_t_3;
  __pyx_t_3 = 0;

 3194:         # Just scale up the number so that it fits on the same scale and will be visible after plotting

+3195:         return max(-200000.0, min(naive_time_function(theta)*100000.0, 200000.0))

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = 200000.0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_naive_time_function)) { __Pyx_RaiseClosureNameError("naive_time_function"); __PYX_ERR(0, 3195, __pyx_L1_error) }
  __pyx_t_2 = __pyx_pf_14neo_controller_18solve_interception_4naive_time_function(__pyx_cur_scope->__pyx_v_naive_time_function, __pyx_v_theta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_mstate_global->__pyx_float_100000_0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_6) {
    __pyx_t_5 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3195, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_2 = __pyx_t_5;
    __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_2 = __pyx_t_3;
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = __pyx_t_2;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_1 = -200000.0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3195, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_6) {
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_2 = __pyx_t_3;
  } else {
    __pyx_t_4 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3195, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __pyx_t_4;
    __pyx_t_4 = 0;
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  goto __pyx_L0;

 3196: 

+3197:     def root_function(theta: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_9root_function(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_9root_function = {"root_function", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_9root_function, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_9root_function(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("root_function (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3197, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3197, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "root_function", 0) < 0) __PYX_ERR(0, 3197, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("root_function", 1, 1, 1, i); __PYX_ERR(0, 3197, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3197, __pyx_L3_error)
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3197, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("root_function", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3197, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.root_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_8root_function(__pyx_self, __pyx_v_theta);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_8root_function(PyObject *__pyx_self, double __pyx_v_theta) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  PyObject *__pyx_v_abs_delta_theta = NULL;
  double __pyx_v_cos_theta;
  double __pyx_v_sin_theta;
  PyObject *__pyx_v_sinusoidal_component = NULL;
  PyObject *__pyx_v_wacky_component = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.solve_interception.root_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_abs_delta_theta);
  __Pyx_XDECREF(__pyx_v_sinusoidal_component);
  __Pyx_XDECREF(__pyx_v_wacky_component);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3197, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3197, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_9root_function, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_root_f, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GIVEREF(__pyx_t_5);
  __pyx_cur_scope->__pyx_v_root_function = __pyx_t_5;
  __pyx_t_5 = 0;

 3198:         # Convert heading error to absolute heading

+3199:         theta += theta_0

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3199, __pyx_L1_error) }
  __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3199, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_theta = __pyx_t_3;

 3200:         # Domain of this function is theta_0 - pi to theta_0 + pi

 3201:         # Make this function periodic by wrapping inputs outside this range, to within the range

+3202:         if not (theta_0 - pi <= theta <= theta_0 + pi):

  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3202, __pyx_L1_error) }
  __pyx_t_2 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyNumber_Subtract(__pyx_cur_scope->__pyx_v_theta_0, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3202, __pyx_L1_error)
  if (__Pyx_PyObject_IsTrue(__pyx_t_4)) {
    __Pyx_DECREF(__pyx_t_4);
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3202, __pyx_L1_error) }
    __pyx_t_5 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3202, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Add(__pyx_cur_scope->__pyx_v_theta_0, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3202, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3202, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 3202, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_8 = (!__pyx_t_7);
  if (__pyx_t_8) {
/* … */
  }

+3203:             theta = (theta - theta_0 + pi) % TAU - pi + theta_0

    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3203, __pyx_L1_error) }
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = PyNumber_Remainder(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3203, __pyx_L1_error) }
    __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3203, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_theta = __pyx_t_3;

+3204:         abs_delta_theta = abs(theta - theta_0)

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3204, __pyx_L1_error) }
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_4, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyNumber_Absolute(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_abs_delta_theta = __pyx_t_4;
  __pyx_t_4 = 0;

+3205:         cos_theta = cos(theta)

  __pyx_v_cos_theta = cos(__pyx_v_theta);

+3206:         sin_theta = sin(theta)

  __pyx_v_sin_theta = sin(__pyx_v_theta);

+3207:         sinusoidal_component = k1*cos_theta - k2*sin_theta + k3

  if (unlikely(!__pyx_cur_scope->__pyx_v_k1)) { __Pyx_RaiseClosureNameError("k1"); __PYX_ERR(0, 3207, __pyx_L1_error) }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_k1, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_k2)) { __Pyx_RaiseClosureNameError("k2"); __PYX_ERR(0, 3207, __pyx_L1_error) }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_k2, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_k3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_sinusoidal_component = __pyx_t_1;
  __pyx_t_1 = 0;

+3208:         wacky_component = vb*abs_delta_theta/pi*(avy*cos_theta - avx*sin_theta)

  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3208, __pyx_L1_error) }
  __pyx_t_1 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_v_abs_delta_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(((__pyx_cur_scope->__pyx_v_avy * __pyx_v_cos_theta) - (__pyx_cur_scope->__pyx_v_avx * __pyx_v_sin_theta))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyNumber_Multiply(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_wacky_component = __pyx_t_1;
  __pyx_t_1 = 0;

+3209:         return sinusoidal_component + wacky_component

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyNumber_Add(__pyx_v_sinusoidal_component, __pyx_v_wacky_component); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3209, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3210: 

+3211:     def root_function_derivative(theta: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_11root_function_derivative(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_11root_function_derivative = {"root_function_derivative", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_11root_function_derivative, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_11root_function_derivative(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("root_function_derivative (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3211, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3211, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "root_function_derivative", 0) < 0) __PYX_ERR(0, 3211, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("root_function_derivative", 1, 1, 1, i); __PYX_ERR(0, 3211, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3211, __pyx_L3_error)
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3211, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("root_function_derivative", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3211, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.root_function_derivative", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_10root_function_derivative(__pyx_self, __pyx_v_theta);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_10root_function_derivative(PyObject *__pyx_self, double __pyx_v_theta) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  double __pyx_v_cos_theta;
  double __pyx_v_sin_theta;
  PyObject *__pyx_v_sinusoidal_component = NULL;
  PyObject *__pyx_v_wacky_component = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.solve_interception.root_function_derivative", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_sinusoidal_component);
  __Pyx_XDECREF(__pyx_v_wacky_component);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3211, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3211, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_11root_function_derivative, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_root_f_2, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GIVEREF(__pyx_t_3);
  __pyx_cur_scope->__pyx_v_root_function_derivative = __pyx_t_3;
  __pyx_t_3 = 0;

 3212:         # Convert heading error to absolute heading

+3213:         theta += theta_0

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3213, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3213, __pyx_L1_error) }
  __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3213, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3213, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_theta = __pyx_t_3;

 3214:         # Domain of this function is theta_0 - pi to theta_0 + pi

 3215:         # Make this function periodic by wrapping inputs outside this range, to within the range

+3216:         if not (theta_0 - pi <= theta <= theta_0 + pi):

  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3216, __pyx_L1_error) }
  __pyx_t_2 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyNumber_Subtract(__pyx_cur_scope->__pyx_v_theta_0, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3216, __pyx_L1_error)
  if (__Pyx_PyObject_IsTrue(__pyx_t_4)) {
    __Pyx_DECREF(__pyx_t_4);
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3216, __pyx_L1_error) }
    __pyx_t_5 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3216, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Add(__pyx_cur_scope->__pyx_v_theta_0, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3216, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3216, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 3216, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_8 = (!__pyx_t_7);
  if (__pyx_t_8) {
/* … */
  }

+3217:             theta = (theta - theta_0 + pi) % TAU - pi + theta_0

    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3217, __pyx_L1_error) }
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = PyNumber_Remainder(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3217, __pyx_L1_error) }
    __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3217, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_theta = __pyx_t_3;

+3218:         cos_theta = cos(theta)

  __pyx_v_cos_theta = cos(__pyx_v_theta);

+3219:         sin_theta = sin(theta)

  __pyx_v_sin_theta = sin(__pyx_v_theta);

+3220:         sinusoidal_component = -k1*sin_theta - k2*cos_theta

  if (unlikely(!__pyx_cur_scope->__pyx_v_k1)) { __Pyx_RaiseClosureNameError("k1"); __PYX_ERR(0, 3220, __pyx_L1_error) }
  __pyx_t_4 = PyNumber_Negative(__pyx_cur_scope->__pyx_v_k1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_k2)) { __Pyx_RaiseClosureNameError("k2"); __PYX_ERR(0, 3220, __pyx_L1_error) }
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_k2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_sinusoidal_component = __pyx_t_1;
  __pyx_t_1 = 0;

+3221:         wacky_component = -vb*sign(theta - theta_0)/pi*(avx*sin_theta - avy*cos_theta + (theta - theta_0)*(avx*cos_theta + avy*sin_theta))

  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3221, __pyx_L1_error) }
  __pyx_t_1 = PyNumber_Negative(__pyx_cur_scope->__pyx_v_vb); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3221, __pyx_L1_error) }
  __pyx_t_9 = PyNumber_Subtract(__pyx_t_5, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_10 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_10 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_9};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3221, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(((__pyx_cur_scope->__pyx_v_avx * __pyx_v_sin_theta) - (__pyx_cur_scope->__pyx_v_avy * __pyx_v_cos_theta))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3221, __pyx_L1_error) }
  __pyx_t_9 = PyNumber_Subtract(__pyx_t_6, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyFloat_FromDouble(((__pyx_cur_scope->__pyx_v_avx * __pyx_v_cos_theta) + (__pyx_cur_scope->__pyx_v_avy * __pyx_v_sin_theta))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_wacky_component = __pyx_t_2;
  __pyx_t_2 = 0;

+3222:         return sinusoidal_component + wacky_component

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyNumber_Add(__pyx_v_sinusoidal_component, __pyx_v_wacky_component); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 3223: 

+3224:     def root_function_second_derivative(theta: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_13root_function_second_derivative(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_13root_function_second_derivative = {"root_function_second_derivative", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_13root_function_second_derivative, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_13root_function_second_derivative(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("root_function_second_derivative (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3224, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3224, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "root_function_second_derivative", 0) < 0) __PYX_ERR(0, 3224, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("root_function_second_derivative", 1, 1, 1, i); __PYX_ERR(0, 3224, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3224, __pyx_L3_error)
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3224, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("root_function_second_derivative", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3224, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.root_function_second_derivative", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_12root_function_second_derivative(__pyx_self, __pyx_v_theta);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_12root_function_second_derivative(PyObject *__pyx_self, double __pyx_v_theta) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  double __pyx_v_cos_theta;
  double __pyx_v_sin_theta;
  PyObject *__pyx_v_sinusoidal_component = NULL;
  PyObject *__pyx_v_wacky_component = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.solve_interception.root_function_second_derivative", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_sinusoidal_component);
  __Pyx_XDECREF(__pyx_v_wacky_component);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3224, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3224, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3224, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_13root_function_second_derivative, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_root_f_3, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3224, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GIVEREF(__pyx_t_5);
  __pyx_cur_scope->__pyx_v_root_function_second_derivative = __pyx_t_5;
  __pyx_t_5 = 0;

 3225:         # Convert heading error to absolute heading

+3226:         theta += theta_0

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3226, __pyx_L1_error) }
  __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3226, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_theta = __pyx_t_3;

 3227:         # Domain of this function is theta_0 - pi to theta_0 + pi

 3228:         # Make this function periodic by wrapping inputs outside this range, to within the range

+3229:         if not (theta_0 - pi <= theta <= theta_0 + pi):

  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3229, __pyx_L1_error) }
  __pyx_t_2 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyNumber_Subtract(__pyx_cur_scope->__pyx_v_theta_0, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3229, __pyx_L1_error)
  if (__Pyx_PyObject_IsTrue(__pyx_t_4)) {
    __Pyx_DECREF(__pyx_t_4);
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3229, __pyx_L1_error) }
    __pyx_t_5 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3229, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Add(__pyx_cur_scope->__pyx_v_theta_0, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3229, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3229, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 3229, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_8 = (!__pyx_t_7);
  if (__pyx_t_8) {
/* … */
  }

+3230:             theta = (theta - theta_0 + pi) % TAU - pi + theta_0

    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3230, __pyx_L1_error) }
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = PyNumber_Remainder(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3230, __pyx_L1_error) }
    __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3230, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_theta = __pyx_t_3;

+3231:         cos_theta = cos(theta)

  __pyx_v_cos_theta = cos(__pyx_v_theta);

+3232:         sin_theta = sin(theta)

  __pyx_v_sin_theta = sin(__pyx_v_theta);

+3233:         sinusoidal_component = -k1*cos_theta + k2*sin_theta

  if (unlikely(!__pyx_cur_scope->__pyx_v_k1)) { __Pyx_RaiseClosureNameError("k1"); __PYX_ERR(0, 3233, __pyx_L1_error) }
  __pyx_t_4 = PyNumber_Negative(__pyx_cur_scope->__pyx_v_k1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_k2)) { __Pyx_RaiseClosureNameError("k2"); __PYX_ERR(0, 3233, __pyx_L1_error) }
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_k2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_sinusoidal_component = __pyx_t_1;
  __pyx_t_1 = 0;

+3234:         wacky_component = -vb*sign(theta - theta_0)/pi*(2.0*(avx*cos_theta + avy*sin_theta) - (theta - theta_0)*(avx*sin_theta - avy*cos_theta))

  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3234, __pyx_L1_error) }
  __pyx_t_1 = PyNumber_Negative(__pyx_cur_scope->__pyx_v_vb); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3234, __pyx_L1_error) }
  __pyx_t_9 = PyNumber_Subtract(__pyx_t_5, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_10 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_10 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_9};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3234, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble((2.0 * ((__pyx_cur_scope->__pyx_v_avx * __pyx_v_cos_theta) + (__pyx_cur_scope->__pyx_v_avy * __pyx_v_sin_theta)))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3234, __pyx_L1_error) }
  __pyx_t_9 = PyNumber_Subtract(__pyx_t_6, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyFloat_FromDouble(((__pyx_cur_scope->__pyx_v_avx * __pyx_v_sin_theta) - (__pyx_cur_scope->__pyx_v_avy * __pyx_v_cos_theta))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Subtract(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_wacky_component = __pyx_t_2;
  __pyx_t_2 = 0;

+3235:         return sinusoidal_component + wacky_component

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyNumber_Add(__pyx_v_sinusoidal_component, __pyx_v_wacky_component); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 3236: 

 3237:     # I inlined the functions, but you could add them back to the function call.

+3238:     def turbo_rootinator_5000(initial_guess: float, tolerance: float = EPS, max_iterations: int = 4) -> float:  # function: Callable[[float], float], derivative_function: Callable[[float], float], second_derivative_function: Callable[[float], float]

static PyObject *__pyx_pf_14neo_controller_163__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 3238, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_int_4));
  __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_int_4));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject*)__pyx_mstate_global->__pyx_int_4)) != (0)) __PYX_ERR(0, 3238, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 3238, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, Py_None) != (0)) __PYX_ERR(0, 3238, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_15turbo_rootinator_5000(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_15turbo_rootinator_5000 = {"turbo_rootinator_5000", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_15turbo_rootinator_5000, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_15turbo_rootinator_5000(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_initial_guess;
  double __pyx_v_tolerance;
  PyObject *__pyx_v_max_iterations = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("turbo_rootinator_5000 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_initial_guess,&__pyx_mstate_global->__pyx_n_u_tolerance,&__pyx_mstate_global->__pyx_n_u_max_iterations,0};
  PyObject* values[3] = {0,0,0};
    struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self);
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3238, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "turbo_rootinator_5000", 0) < 0) __PYX_ERR(0, 3238, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_4)));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("turbo_rootinator_5000", 0, 1, 3, i); __PYX_ERR(0, 3238, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3238, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3238, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_4)));
    }
    __pyx_v_initial_guess = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_initial_guess == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3238, __pyx_L3_error)
    if (values[1]) {
      __pyx_v_tolerance = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3238, __pyx_L3_error)
    } else {
      __pyx_v_tolerance = __pyx_dynamic_args->arg0;
    }
    __pyx_v_max_iterations = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("turbo_rootinator_5000", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 3238, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.turbo_rootinator_5000", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_max_iterations), (&PyLong_Type), 0, "max_iterations", 2))) __PYX_ERR(0, 3238, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_14turbo_rootinator_5000(__pyx_self, __pyx_v_initial_guess, __pyx_v_tolerance, __pyx_v_max_iterations);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_14turbo_rootinator_5000(PyObject *__pyx_self, double __pyx_v_initial_guess, double __pyx_v_tolerance, PyObject *__pyx_v_max_iterations) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  double __pyx_v_theta_old;
  PyObject *__pyx_v_initial_func_value = 0;
  double __pyx_v_theta_new;
  double __pyx_v_func_value;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_v_derivative_value = NULL;
  PyObject *__pyx_v_second_derivative_value = NULL;
  PyObject *__pyx_v_denominator = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.solve_interception.turbo_rootinator_5000", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_initial_func_value);
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XDECREF(__pyx_v_derivative_value);
  __Pyx_XDECREF(__pyx_v_second_derivative_value);
  __Pyx_XDECREF(__pyx_v_denominator);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_initial_guess, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3238, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_tolerance, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3238, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_max_iterations, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3238, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3238, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_15turbo_rootinator_5000, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_turbo, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_defaults)) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_3)->arg0 = __pyx_v_14neo_controller_EPS;
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_3, __pyx_pf_14neo_controller_163__defaults__);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_GIVEREF(__pyx_t_3);
  __pyx_cur_scope->__pyx_v_turbo_rootinator_5000 = __pyx_t_3;
  __pyx_t_3 = 0;

+3239:         theta_old: float = initial_guess

  __pyx_v_theta_old = __pyx_v_initial_guess;

 3240:         # debug_print(f"Our initial guess is {initial_guess} which gives function value {function(initial_guess)}")

+3241:         initial_func_value: Optional[float] = None

  __Pyx_INCREF(Py_None);
  __pyx_v_initial_func_value = ((PyObject*)Py_None);

 3242:         theta_new: float

 3243:         func_value: float

+3244:         for _ in range(max_iterations):

  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_range);
  __pyx_t_3 = __pyx_builtin_range; 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_max_iterations};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3244, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3244, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3244, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  for (;;) {
    if (likely(!__pyx_t_6)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3244, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3244, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3244, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3244, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 3244, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v__, ((PyObject*)__pyx_t_1));
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3245:             func_value = root_function(theta_old)

    if (unlikely(!__pyx_cur_scope->__pyx_v_root_function)) { __Pyx_RaiseClosureNameError("root_function"); __PYX_ERR(0, 3245, __pyx_L1_error) }
    __pyx_t_1 = __pyx_pf_14neo_controller_18solve_interception_8root_function(__pyx_cur_scope->__pyx_v_root_function, __pyx_v_theta_old); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3245, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3245, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_func_value = __pyx_t_7;

+3246:             if abs(func_value) < TAD:

    __pyx_t_7 = fabs(__pyx_v_func_value); 
    __pyx_t_8 = (__pyx_t_7 < __pyx_v_14neo_controller_TAD);
    if (__pyx_t_8) {
/* … */
    }

+3247:                 return theta_old

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta_old); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3247, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_r = __pyx_t_1;
      __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      goto __pyx_L0;

+3248:             if not initial_func_value:

    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_initial_func_value); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3248, __pyx_L1_error)
    __pyx_t_9 = (!__pyx_t_8);
    if (__pyx_t_9) {
/* … */
    }

+3249:                 initial_func_value = func_value

      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_func_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3249, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!(likely(PyFloat_CheckExact(__pyx_t_1)) || __Pyx_RaiseUnexpectedTypeError("float", __pyx_t_1))) __PYX_ERR(0, 3249, __pyx_L1_error)
      __Pyx_DECREF_SET(__pyx_v_initial_func_value, ((PyObject*)__pyx_t_1));
      __pyx_t_1 = 0;

+3250:             derivative_value = root_function_derivative(theta_old)

    if (unlikely(!__pyx_cur_scope->__pyx_v_root_function_derivative)) { __Pyx_RaiseClosureNameError("root_function_derivative"); __PYX_ERR(0, 3250, __pyx_L1_error) }
    __pyx_t_1 = __pyx_pf_14neo_controller_18solve_interception_10root_function_derivative(__pyx_cur_scope->__pyx_v_root_function_derivative, __pyx_v_theta_old); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3250, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_derivative_value, __pyx_t_1);
    __pyx_t_1 = 0;

+3251:             second_derivative_value = root_function_second_derivative(theta_old)

    if (unlikely(!__pyx_cur_scope->__pyx_v_root_function_second_derivative)) { __Pyx_RaiseClosureNameError("root_function_second_derivative"); __PYX_ERR(0, 3251, __pyx_L1_error) }
    __pyx_t_1 = __pyx_pf_14neo_controller_18solve_interception_12root_function_second_derivative(__pyx_cur_scope->__pyx_v_root_function_second_derivative, __pyx_v_theta_old); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3251, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_second_derivative_value, __pyx_t_1);
    __pyx_t_1 = 0;

 3252: 

 3253:             # Update the estimate using Halley's method

+3254:             denominator = 2.0*derivative_value*derivative_value - func_value*second_derivative_value

    __pyx_t_1 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_2_0, __pyx_v_derivative_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3254, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_derivative_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3254, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_func_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3254, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_10 = PyNumber_Multiply(__pyx_t_1, __pyx_v_second_derivative_value); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3254, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3254, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF_SET(__pyx_v_denominator, __pyx_t_1);
    __pyx_t_1 = 0;

+3255:             if denominator == 0.0:

    __pyx_t_9 = (__Pyx_PyFloat_BoolEqObjC(__pyx_v_denominator, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 3255, __pyx_L1_error)
    if (__pyx_t_9) {
/* … */
    }

+3256:                 return NAN

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3256, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_r = __pyx_t_1;
      __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      goto __pyx_L0;

+3257:             theta_new = theta_old - (2.0*func_value*derivative_value)/denominator

    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta_old); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3257, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_10 = PyFloat_FromDouble((2.0 * __pyx_v_func_value)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3257, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_2 = PyNumber_Multiply(__pyx_t_10, __pyx_v_derivative_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3257, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_v_denominator); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3257, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3257, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3257, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_theta_new = __pyx_t_7;

 3258:             # The value has jumped past the periodic boundary. Clamp it to right past the boundary just so things don't get too crazy.

+3259:             if theta_new < -pi:

    __pyx_t_9 = (__pyx_v_theta_new < (-M_PI));
    if (__pyx_t_9) {
/* … */
      goto __pyx_L8;
    }

+3260:                 theta_new = pi - GRAIN

      __pyx_v_theta_new = (M_PI - __pyx_v_14neo_controller_GRAIN);

+3261:             elif pi < theta_new:

    __pyx_t_9 = (M_PI < __pyx_v_theta_new);
    if (__pyx_t_9) {
/* … */
      goto __pyx_L8;
    }

+3262:                 theta_new = -pi + GRAIN

      __pyx_v_theta_new = ((-M_PI) + __pyx_v_14neo_controller_GRAIN);

+3263:             elif -pi <= theta_old <= 0.0 <= theta_new <= pi:

    __pyx_t_9 = ((-M_PI) <= __pyx_v_theta_old);
    if (__pyx_t_9) {
      __pyx_t_9 = (__pyx_v_theta_old <= 0.0);
      if (__pyx_t_9) {
        __pyx_t_9 = (0.0 <= __pyx_v_theta_new);
        if (__pyx_t_9) {
          __pyx_t_9 = (__pyx_v_theta_new <= M_PI);
        }
      }
    }
    if (__pyx_t_9) {
/* … */
      goto __pyx_L8;
    }

 3264:                 # The value jumped past the kink in the middle of the graph. set it to right past the kink so the value doesn't jump around like crazy

+3265:                 theta_new = GRAIN

      __pyx_v_theta_new = __pyx_v_14neo_controller_GRAIN;

+3266:             elif -pi <= theta_new <= 0.0 <= theta_old <= pi:

    __pyx_t_9 = ((-M_PI) <= __pyx_v_theta_new);
    if (__pyx_t_9) {
      __pyx_t_9 = (__pyx_v_theta_new <= 0.0);
      if (__pyx_t_9) {
        __pyx_t_9 = (0.0 <= __pyx_v_theta_old);
        if (__pyx_t_9) {
          __pyx_t_9 = (__pyx_v_theta_old <= M_PI);
        }
      }
    }
    if (__pyx_t_9) {
/* … */
    }
    __pyx_L8:;

+3267:                 theta_new = -GRAIN

      __pyx_v_theta_new = (-__pyx_v_14neo_controller_GRAIN);

 3268: 

 3269:             # debug_print(f"After iteration {iteration + 1}, our new theta value is {theta_new}. Func value is {func_value}")

 3270:             # Check for convergence

 3271:             # It converged if the theta value isn't changing much, and the function itself takes a value that is close to zero (magnitude at most 1% of the original func value)

+3272:             if abs(theta_new - theta_old) < tolerance and abs(func_value) < 0.1*abs(initial_func_value):

    __pyx_t_7 = fabs((__pyx_v_theta_new - __pyx_v_theta_old)); 
    __pyx_t_8 = (__pyx_t_7 < __pyx_v_tolerance);
    if (__pyx_t_8) {
    } else {
      __pyx_t_9 = __pyx_t_8;
      goto __pyx_L10_bool_binop_done;
    }
    __pyx_t_7 = fabs(__pyx_v_func_value); 
    __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_v_initial_func_value); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3272, __pyx_L1_error)
    __pyx_t_12 = fabs(__pyx_t_11); 
    __pyx_t_8 = (__pyx_t_7 < (0.1 * __pyx_t_12));
    __pyx_t_9 = __pyx_t_8;
    __pyx_L10_bool_binop_done:;
    if (__pyx_t_9) {
/* … */
    }

+3273:                 return theta_new

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_2 = PyFloat_FromDouble(__pyx_v_theta_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3273, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      goto __pyx_L0;

+3274:             theta_old = theta_new

    __pyx_v_theta_old = __pyx_v_theta_new;

+3275:         return NAN

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3275, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 3276: 

+3277:     def rotation_time(delta_theta_rad: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_17rotation_time(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_17rotation_time = {"rotation_time", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_17rotation_time, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_17rotation_time(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_delta_theta_rad;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("rotation_time (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_delta_theta_rad,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3277, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3277, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "rotation_time", 0) < 0) __PYX_ERR(0, 3277, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("rotation_time", 1, 1, 1, i); __PYX_ERR(0, 3277, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3277, __pyx_L3_error)
    }
    __pyx_v_delta_theta_rad = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_delta_theta_rad == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3277, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("rotation_time", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3277, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.rotation_time", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_16rotation_time(__pyx_self, __pyx_v_delta_theta_rad);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_16rotation_time(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_delta_theta_rad) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.solve_interception.rotation_time", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3277, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_delta_theta_rad, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3277, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3277, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_17rotation_time, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_rotati, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3277, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GIVEREF(__pyx_t_5);
  __pyx_cur_scope->__pyx_v_rotation_time = __pyx_t_5;
  __pyx_t_5 = 0;

+3278:         return abs(delta_theta_rad)*SHIP_MAX_TURN_RATE_RAD_RECIPROCAL

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = fabs(__pyx_v_delta_theta_rad); 
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3278, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_RAD_RECIPROCA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3278, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3278, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 3279: 

+3280:     def bullet_travel_time(theta: float, t_rot: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_19bullet_travel_time(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_19bullet_travel_time = {"bullet_travel_time", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_19bullet_travel_time, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_19bullet_travel_time(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  double __pyx_v_t_rot;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("bullet_travel_time (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,&__pyx_mstate_global->__pyx_n_u_t_rot,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3280, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3280, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3280, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bullet_travel_time", 0) < 0) __PYX_ERR(0, 3280, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bullet_travel_time", 1, 2, 2, i); __PYX_ERR(0, 3280, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3280, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3280, __pyx_L3_error)
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3280, __pyx_L3_error)
    __pyx_v_t_rot = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_t_rot == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3280, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("bullet_travel_time", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3280, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.bullet_travel_time", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_18bullet_travel_time(__pyx_self, __pyx_v_theta, __pyx_v_t_rot);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_18bullet_travel_time(PyObject *__pyx_self, double __pyx_v_theta, double __pyx_v_t_rot) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  double __pyx_v_cos_theta;
  double __pyx_v_sin_theta;
  PyObject *__pyx_v_denominator_x = NULL;
  PyObject *__pyx_v_denominator_y = NULL;
  PyObject *__pyx_v_t_bul = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.solve_interception.bullet_travel_time", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_denominator_x);
  __Pyx_XDECREF(__pyx_v_denominator_y);
  __Pyx_XDECREF(__pyx_v_t_bul);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3280, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3280, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_t_rot, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3280, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3280, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_19bullet_travel_time, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_bullet, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3280, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_bullet_travel_time = __pyx_t_3;
  __pyx_t_3 = 0;

 3281:         # Convert heading error to absolute heading

+3282:         theta += theta_0

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3282, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3282, __pyx_L1_error) }
  __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3282, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3282, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_theta = __pyx_t_3;

+3283:         cos_theta = cos(theta)

  __pyx_v_cos_theta = cos(__pyx_v_theta);

+3284:         sin_theta = sin(theta)

  __pyx_v_sin_theta = sin(__pyx_v_theta);

+3285:         denominator_x = avx - vb*cos_theta

  __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3285, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3285, __pyx_L1_error) }
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3285, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3285, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3285, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_denominator_x = __pyx_t_1;
  __pyx_t_1 = 0;

+3286:         denominator_y = avy - vb*sin_theta

  __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3286, __pyx_L1_error) }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Subtract(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_denominator_y = __pyx_t_4;
  __pyx_t_4 = 0;

+3287:         if denominator_x == 0.0 and denominator_y == 0.0:

  __pyx_t_6 = (__Pyx_PyFloat_BoolEqObjC(__pyx_v_denominator_x, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3287, __pyx_L1_error)
  if (__pyx_t_6) {
  } else {
    __pyx_t_5 = __pyx_t_6;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_6 = (__Pyx_PyFloat_BoolEqObjC(__pyx_v_denominator_y, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3287, __pyx_L1_error)
  __pyx_t_5 = __pyx_t_6;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_5) {
/* … */
  }

+3288:             return INFINITY

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3288, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 3289:         # At least one of the denominators is nonzero, so if we choose the one with the larger magnitude, we'll avoid division by zero as well as get the more accurate answer

+3290:         if abs(denominator_x) > abs(denominator_y):

  __pyx_t_4 = __Pyx_PyNumber_Absolute(__pyx_v_denominator_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3290, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_v_denominator_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3290, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3290, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3290, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_5) {
/* … */
    goto __pyx_L6;
  }

+3291:             t_bul = (vb*t_0*cos_theta - ax - avx*t_rot)/denominator_x

    if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3291, __pyx_L1_error) }
    __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyNumber_Multiply(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ax); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble((__pyx_cur_scope->__pyx_v_avx * __pyx_v_t_rot)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyNumber_Subtract(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_4, __pyx_v_denominator_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3291, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_t_bul = __pyx_t_1;
    __pyx_t_1 = 0;

 3292:         else:

+3293:             t_bul = (vb*t_0*sin_theta - ay - avy*t_rot)/denominator_y

  /*else*/ {
    if (unlikely(!__pyx_cur_scope->__pyx_v_vb)) { __Pyx_RaiseClosureNameError("vb"); __PYX_ERR(0, 3293, __pyx_L1_error) }
    __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ay); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyNumber_Subtract(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble((__pyx_cur_scope->__pyx_v_avy * __pyx_v_t_rot)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_v_denominator_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3293, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_t_bul = __pyx_t_1;
    __pyx_t_1 = 0;
  }
  __pyx_L6:;

+3294:         return t_bul

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_t_bul);
  __pyx_r = __pyx_v_t_bul;
  goto __pyx_L0;

 3295: 

+3296:     def bullet_travel_time_for_plot(theta: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_21bullet_travel_time_for_plot(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_21bullet_travel_time_for_plot = {"bullet_travel_time_for_plot", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_18solve_interception_21bullet_travel_time_for_plot, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_21bullet_travel_time_for_plot(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_theta;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("bullet_travel_time_for_plot (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_theta,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3296, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3296, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bullet_travel_time_for_plot", 0) < 0) __PYX_ERR(0, 3296, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bullet_travel_time_for_plot", 1, 1, 1, i); __PYX_ERR(0, 3296, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3296, __pyx_L3_error)
    }
    __pyx_v_theta = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3296, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("bullet_travel_time_for_plot", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3296, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.solve_interception.bullet_travel_time_for_plot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_20bullet_travel_time_for_plot(__pyx_self, __pyx_v_theta);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_20bullet_travel_time_for_plot(PyObject *__pyx_self, double __pyx_v_theta) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  double __pyx_v_cos_theta;
  double __pyx_v_sin_theta;
  PyObject *__pyx_v_t_rot = NULL;
  double __pyx_v_denominator;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.solve_interception.bullet_travel_time_for_plot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_t_rot);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3296, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_theta, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3296, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3296, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_21bullet_travel_time_for_plot, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_bullet_2, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3296, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GIVEREF(__pyx_t_5);
  __pyx_cur_scope->__pyx_v_bullet_travel_time_for_plot = __pyx_t_5;
  __pyx_t_5 = 0;

 3297:         # USED FOR DEBUGGING

 3298:         # Convert heading error to absolute heading

+3299:         theta += theta_0

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3299, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3299, __pyx_L1_error) }
  __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3299, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3299, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_theta = __pyx_t_3;

+3300:         cos_theta = cos(theta)

  __pyx_v_cos_theta = cos(__pyx_v_theta);

+3301:         sin_theta = sin(theta)

  __pyx_v_sin_theta = sin(__pyx_v_theta);

+3302:         t_rot = rotation_time(theta - theta_0)

  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3302, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (unlikely(!__pyx_cur_scope->__pyx_v_theta_0)) { __Pyx_RaiseClosureNameError("theta_0"); __PYX_ERR(0, 3302, __pyx_L1_error) }
  __pyx_t_1 = PyNumber_Subtract(__pyx_t_2, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3302, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_3 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3302, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_rotation_time)) { __Pyx_RaiseClosureNameError("rotation_time"); __PYX_ERR(0, 3302, __pyx_L1_error) }
  __pyx_t_1 = __pyx_pf_14neo_controller_18solve_interception_16rotation_time(__pyx_cur_scope->__pyx_v_rotation_time, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3302, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_t_rot = __pyx_t_1;
  __pyx_t_1 = 0;

 3303: 

+3304:         denominator = avx*sin_theta - avy*cos_theta

  __pyx_v_denominator = ((__pyx_cur_scope->__pyx_v_avx * __pyx_v_sin_theta) - (__pyx_cur_scope->__pyx_v_avy * __pyx_v_cos_theta));

+3305:         if denominator == 0.0:

  __pyx_t_4 = (__pyx_v_denominator == 0.0);
  if (__pyx_t_4) {
/* … */
  }

+3306:             return INFINITY

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3306, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

 3307:         else:

+3308:             return max(-200000.0, min(((cos_theta*(ay + avy*t_rot) - sin_theta*(ax + avx*t_rot))/denominator)*100000.0, 200000.0))

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = 200000.0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_cos_theta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ay); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_5, __pyx_v_t_rot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyNumber_Add(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_sin_theta); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_1 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ax); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_avx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = PyNumber_Multiply(__pyx_t_2, __pyx_v_t_rot); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_denominator); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_Multiply(__pyx_t_6, __pyx_mstate_global->__pyx_float_100000_0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_2 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_4) {
      __pyx_t_5 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3308, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __pyx_t_5;
      __pyx_t_5 = 0;
    } else {
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_6 = __pyx_t_7;
    }
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_7 = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_3 = -200000.0;
    __pyx_t_5 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_7, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3308, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_4) {
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_6 = __pyx_t_7;
    } else {
      __pyx_t_2 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3308, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = __pyx_t_2;
      __pyx_t_2 = 0;
    }
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_r = __pyx_t_6;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L0;
  }

 3309: 

+3310:     def plot_function() -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_18solve_interception_23plot_function(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_18solve_interception_23plot_function = {"plot_function", (PyCFunction)__pyx_pw_14neo_controller_18solve_interception_23plot_function, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_18solve_interception_23plot_function(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("plot_function (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_18solve_interception_22plot_function(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_18solve_interception_22plot_function(PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *__pyx_outer_scope;
  PyObject *__pyx_v_naive_theta_ans_list = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_theta_0 = NULL;
  PyObject *__pyx_v_theta_delta_range = NULL;
  PyObject *__pyx_v_vectorized_function = NULL;
  PyObject *__pyx_v_vectorized_derivative = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_vectorized_second_derivative = NULL;
  PyObject *__pyx_v_vectorized_bullet_time = NULL;
  PyObject *__pyx_v_vectorized_naive_function = NULL;
  PyObject *__pyx_v_vectorized_naive_time = NULL;
  PyObject *__pyx_v_function_values = NULL;
  PyObject *__pyx_v_derivative_values = NULL;
  PyObject *__pyx_v_bullet_times = NULL;
  PyObject *__pyx_v_naive_function_values = NULL;
  PyObject *__pyx_v_naive_times = NULL;
  PyObject *__pyx_v_fudge = NULL;
  PyObject *__pyx_v_theta_ans = NULL;
  PyObject *__pyx_v_zero = NULL;
  PyObject *__pyx_v_delta_theta_solution = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_10_solve_interception *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.solve_interception.plot_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_naive_theta_ans_list);
  __Pyx_XDECREF(__pyx_v_theta_0);
  __Pyx_XDECREF(__pyx_v_theta_delta_range);
  __Pyx_XDECREF(__pyx_v_vectorized_function);
  __Pyx_XDECREF(__pyx_v_vectorized_derivative);
  __Pyx_XDECREF(__pyx_v_vectorized_second_derivative);
  __Pyx_XDECREF(__pyx_v_vectorized_bullet_time);
  __Pyx_XDECREF(__pyx_v_vectorized_naive_function);
  __Pyx_XDECREF(__pyx_v_vectorized_naive_time);
  __Pyx_XDECREF(__pyx_v_function_values);
  __Pyx_XDECREF(__pyx_v_derivative_values);
  __Pyx_XDECREF(__pyx_v_bullet_times);
  __Pyx_XDECREF(__pyx_v_naive_function_values);
  __Pyx_XDECREF(__pyx_v_naive_times);
  __Pyx_XDECREF(__pyx_v_fudge);
  __Pyx_XDECREF(__pyx_v_theta_ans);
  __Pyx_XDECREF(__pyx_v_zero);
  __Pyx_XDECREF(__pyx_v_delta_theta_solution);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 3310, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_18solve_interception_23plot_function, 0, __pyx_mstate_global->__pyx_n_u_solve_interception_locals_plot_f, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_plot_function = __pyx_t_3;
  __pyx_t_3 = 0;

 3311:         # USED FOR DEBUGGING

+3312:         naive_theta_ans_list = [naive_desired_heading_calc(timesteps_until_can_fire)]  # Assuming this function returns a list of angles

  if (unlikely(!__pyx_cur_scope->__pyx_v_timesteps_until_can_fire)) { __Pyx_RaiseClosureNameError("timesteps_until_can_fire"); __PYX_ERR(0, 3312, __pyx_L1_error) }
  __pyx_t_1 = __pyx_cur_scope->__pyx_v_timesteps_until_can_fire;
  __Pyx_INCREF(__pyx_t_1);
  if (unlikely(!__pyx_cur_scope->__pyx_v_naive_desired_heading_calc)) { __Pyx_RaiseClosureNameError("naive_desired_heading_calc"); __PYX_ERR(0, 3312, __pyx_L1_error) }
  __pyx_t_2 = __pyx_pf_14neo_controller_18solve_interception_naive_desired_heading_calc(__pyx_cur_scope->__pyx_v_naive_desired_heading_calc, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3312, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3312, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 3312, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_v_naive_theta_ans_list = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+3313:         theta_0 = radians(ship_state.heading)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely(!__pyx_cur_scope->__pyx_v_ship_state)) { __Pyx_RaiseClosureNameError("ship_state"); __PYX_ERR(0, 3313, __pyx_L1_error) }
  __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_ship_state->heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3313, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_theta_0 = __pyx_t_1;
  __pyx_t_1 = 0;

 3314:         # theta_range = linspace(theta_0 - pi, theta_0 + pi, 400)

+3315:         theta_delta_range = linspace(-pi, pi, 400)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_linspace); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = PyFloat_FromDouble((-M_PI)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_t_2, __pyx_t_6, __pyx_mstate_global->__pyx_int_400};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3315, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_theta_delta_range = __pyx_t_1;
  __pyx_t_1 = 0;

 3316: 

 3317:         # Vectorize the functions for numpy compatibility

+3318:         vectorized_function = vectorize(root_function)

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3318, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely(!__pyx_cur_scope->__pyx_v_root_function)) { __Pyx_RaiseClosureNameError("root_function"); __PYX_ERR(0, 3318, __pyx_L1_error) }
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_cur_scope->__pyx_v_root_function};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3318, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_vectorized_function = __pyx_t_1;
  __pyx_t_1 = 0;

+3319:         vectorized_derivative = vectorize(root_function_derivative)

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3319, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (unlikely(!__pyx_cur_scope->__pyx_v_root_function_derivative)) { __Pyx_RaiseClosureNameError("root_function_derivative"); __PYX_ERR(0, 3319, __pyx_L1_error) }
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_root_function_derivative};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3319, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_vectorized_derivative = __pyx_t_1;
  __pyx_t_1 = 0;

+3320:         vectorized_second_derivative = vectorize(root_function_second_derivative)

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely(!__pyx_cur_scope->__pyx_v_root_function_second_derivative)) { __Pyx_RaiseClosureNameError("root_function_second_derivative"); __PYX_ERR(0, 3320, __pyx_L1_error) }
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_cur_scope->__pyx_v_root_function_second_derivative};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3320, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_vectorized_second_derivative = __pyx_t_1;
  __pyx_t_1 = 0;

+3321:         vectorized_bullet_time = vectorize(bullet_travel_time_for_plot)

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (unlikely(!__pyx_cur_scope->__pyx_v_bullet_travel_time_for_plot)) { __Pyx_RaiseClosureNameError("bullet_travel_time_for_plot"); __PYX_ERR(0, 3321, __pyx_L1_error) }
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_bullet_travel_time_for_plot};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3321, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_vectorized_bullet_time = __pyx_t_1;
  __pyx_t_1 = 0;

+3322:         vectorized_naive_function = vectorize(naive_root_function)

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely(!__pyx_cur_scope->__pyx_v_naive_root_function)) { __Pyx_RaiseClosureNameError("naive_root_function"); __PYX_ERR(0, 3322, __pyx_L1_error) }
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_cur_scope->__pyx_v_naive_root_function};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3322, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_vectorized_naive_function = __pyx_t_1;
  __pyx_t_1 = 0;

+3323:         vectorized_naive_time = vectorize(naive_time_function_for_plotting)

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vectorize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3323, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (unlikely(!__pyx_cur_scope->__pyx_v_naive_time_function_for_plotting)) { __Pyx_RaiseClosureNameError("naive_time_function_for_plotting"); __PYX_ERR(0, 3323, __pyx_L1_error) }
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_naive_time_function_for_plotting};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3323, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_vectorized_naive_time = __pyx_t_1;
  __pyx_t_1 = 0;

 3324: 

 3325:         # Calculate function values

+3326:         function_values = vectorized_function(theta_delta_range)

  __pyx_t_4 = NULL;
  __Pyx_INCREF(__pyx_v_vectorized_function);
  __pyx_t_6 = __pyx_v_vectorized_function; 
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_theta_delta_range};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3326, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_function_values = __pyx_t_1;
  __pyx_t_1 = 0;

+3327:         derivative_values = vectorized_derivative(theta_delta_range)

  __pyx_t_6 = NULL;
  __Pyx_INCREF(__pyx_v_vectorized_derivative);
  __pyx_t_4 = __pyx_v_vectorized_derivative; 
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_theta_delta_range};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3327, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_derivative_values = __pyx_t_1;
  __pyx_t_1 = 0;

 3328:         # alt_derivative_values = vectorized_second_derivative(theta_delta_range)

+3329:         bullet_times = vectorized_bullet_time(theta_delta_range)

  __pyx_t_4 = NULL;
  __Pyx_INCREF(__pyx_v_vectorized_bullet_time);
  __pyx_t_6 = __pyx_v_vectorized_bullet_time; 
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_theta_delta_range};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_bullet_times = __pyx_t_1;
  __pyx_t_1 = 0;

+3330:         naive_function_values = vectorized_naive_function(theta_delta_range, float(timesteps_until_can_fire)*DELTA_TIME)

  __pyx_t_6 = NULL;
  __Pyx_INCREF(__pyx_v_vectorized_naive_function);
  __pyx_t_4 = __pyx_v_vectorized_naive_function; 
  if (unlikely(!__pyx_cur_scope->__pyx_v_timesteps_until_can_fire)) { __Pyx_RaiseClosureNameError("timesteps_until_can_fire"); __PYX_ERR(0, 3330, __pyx_L1_error) }
  if (unlikely(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "float() argument must be a string or a number, not 'NoneType'");
    __PYX_ERR(0, 3330, __pyx_L1_error)
  }
  __pyx_t_7 = PyLong_AsDouble(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire); if (unlikely(__pyx_t_7 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3330, __pyx_L1_error)
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_8 = PyNumber_Multiply(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_theta_delta_range, __pyx_t_8};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_naive_function_values = __pyx_t_1;
  __pyx_t_1 = 0;

+3331:         naive_times = vectorized_naive_time(theta_delta_range)

  __pyx_t_4 = NULL;
  __Pyx_INCREF(__pyx_v_vectorized_naive_time);
  __pyx_t_8 = __pyx_v_vectorized_naive_time; 
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_theta_delta_range};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3331, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_naive_times = __pyx_t_1;
  __pyx_t_1 = 0;

 3332: 

+3333:         plt.figure(figsize=(12, 6))

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_figure); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_8, NULL};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3333, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_figsize, __pyx_mstate_global->__pyx_tuple[17], __pyx_t_4, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3333, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_6, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3333, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[17] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_12, __pyx_mstate_global->__pyx_int_6); if (unlikely(!__pyx_mstate_global->__pyx_tuple[17])) __PYX_ERR(0, 3333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[17]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[17]);

 3334: 

 3335:         # Plot the function and its derivatives

+3336:         plt.plot(theta_delta_range, function_values, label="Function")

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3336, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plot); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3336, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_v_theta_delta_range, __pyx_v_function_values};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3336, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_4, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 3336, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_8, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3336, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3337:         plt.plot(theta_delta_range, derivative_values, label="Derivative", color="orange")

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3337, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3337, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_8, __pyx_v_theta_delta_range, __pyx_v_derivative_values};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3337, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_mstate_global->__pyx_n_u_Derivative, __pyx_t_4, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 3337, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_orange, __pyx_t_4, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 3337, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_6, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3337, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 3338:         # plt.plot(theta_delta_range, alt_derivative_values, label="Second Derivative", color="blue", linestyle=':')

+3339:         plt.plot(theta_delta_range, bullet_times, label="Bullet Time", color="green", linestyle='-')

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3339, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plot); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3339, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_6, __pyx_v_theta_delta_range, __pyx_v_bullet_times};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3339, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_mstate_global->__pyx_kp_u_Bullet_Time, __pyx_t_4, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 3339, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_green, __pyx_t_4, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 3339, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_linestyle, __pyx_mstate_global->__pyx_kp_u__14, __pyx_t_4, __pyx_callargs+3, 2) < 0) __PYX_ERR(0, 3339, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_8, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3339, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3340:         plt.plot(theta_delta_range, naive_function_values, label="Naive Function", color="magenta", linestyle='-')

  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3340, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3340, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_8, __pyx_v_theta_delta_range, __pyx_v_naive_function_values};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3340, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_mstate_global->__pyx_kp_u_Naive_Function, __pyx_t_4, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 3340, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_magenta, __pyx_t_4, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 3340, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_linestyle, __pyx_mstate_global->__pyx_kp_u__14, __pyx_t_4, __pyx_callargs+3, 2) < 0) __PYX_ERR(0, 3340, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_6, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3340, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3341:         plt.plot(theta_delta_range, naive_times, label="Naive Times", color="purple", linestyle='-')

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3341, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_plot); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3341, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_6, __pyx_v_theta_delta_range, __pyx_v_naive_times};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3341, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_mstate_global->__pyx_kp_u_Naive_Times, __pyx_t_4, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 3341, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_purple, __pyx_t_4, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 3341, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_linestyle, __pyx_mstate_global->__pyx_kp_u__14, __pyx_t_4, __pyx_callargs+3, 2) < 0) __PYX_ERR(0, 3341, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_8, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3341, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 3342: 

 3343:         # Add vertical lines for each naive_theta_ans

+3344:         fudge = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_fudge = __pyx_mstate_global->__pyx_int_0;

+3345:         for theta_ans in naive_theta_ans_list:

  __pyx_t_1 = __pyx_v_naive_theta_ans_list; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_9 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3345, __pyx_L1_error)
      #endif
      if (__pyx_t_9 >= __pyx_temp) break;
    }
    __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_9);
    ++__pyx_t_9;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3345, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_XDECREF_SET(__pyx_v_theta_ans, __pyx_t_8);
    __pyx_t_8 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3346:             plt.axvline(x=theta_ans[1] + fudge, color='yellow', linestyle='--', label=f"Naive Theta Ans at {theta_ans[1]:.2f}")

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_axvline); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_theta_ans, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_2 = PyNumber_Add(__pyx_t_6, __pyx_v_fudge); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_theta_ans, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_10 = __Pyx_PyObject_Format(__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_2f); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Naive_Theta_Ans_at, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_4, NULL};
      __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3346, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_x, __pyx_t_2, __pyx_t_10, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3346, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_yellow, __pyx_t_10, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 3346, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_linestyle, __pyx_mstate_global->__pyx_kp_u__15, __pyx_t_10, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 3346, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_t_6, __pyx_t_10, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 3346, __pyx_L1_error)
      __pyx_t_8 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3346, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
    }
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 3347: 

+3348:             zero = turbo_rootinator_5000(theta_ans[1] + fudge, TAD, 15)  # root_function, root_function_derivative, root_function_second_derivative

    __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_theta_ans, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_3 = PyNumber_Add(__pyx_t_8, __pyx_v_fudge); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_7 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3348, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_turbo_rootinator_5000)) { __Pyx_RaiseClosureNameError("turbo_rootinator_5000"); __PYX_ERR(0, 3348, __pyx_L1_error) }
    __pyx_t_3 = __pyx_pf_14neo_controller_18solve_interception_14turbo_rootinator_5000(__pyx_cur_scope->__pyx_v_turbo_rootinator_5000, __pyx_t_7, __pyx_v_14neo_controller_TAD, __pyx_mstate_global->__pyx_int_15); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_zero, __pyx_t_3);
    __pyx_t_3 = 0;

+3349:             if not isnan(zero):

    __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_v_zero); if (unlikely((__pyx_t_11 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3349, __pyx_L1_error)
    __pyx_t_12 = (!isnan(__pyx_t_11));
    if (__pyx_t_12) {
/* … */
      goto __pyx_L5;
    }

+3350:                 delta_theta_solution = zero

      __Pyx_INCREF(__pyx_v_zero);
      __Pyx_XDECREF_SET(__pyx_v_delta_theta_solution, __pyx_v_zero);

+3351:                 if not (-pi <= delta_theta_solution <= pi):

      __pyx_t_3 = PyFloat_FromDouble((-M_PI)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3351, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_v_delta_theta_solution, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3351, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_8)) {
        __Pyx_DECREF(__pyx_t_8);
        __pyx_t_10 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3351, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_8 = PyObject_RichCompare(__pyx_v_delta_theta_solution, __pyx_t_10, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3351, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 3351, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_13 = (!__pyx_t_12);
      if (__pyx_t_13) {
/* … */
      }

 3352:                     # print(f"SOLUTION WAS OUT OUT BOUNDS AT {delta_theta_solution} AND WRAPPED TO -pi, pi")

+3353:                     delta_theta_solution = (delta_theta_solution + pi) % TAU - pi

        __pyx_t_8 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3353, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_3 = PyNumber_Add(__pyx_v_delta_theta_solution, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3353, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = PyFloat_FromDouble(__pyx_v_14neo_controller_TAU); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3353, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_10 = PyNumber_Remainder(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3353, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3353, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_3 = PyNumber_Subtract(__pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3353, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF_SET(__pyx_v_delta_theta_solution, __pyx_t_3);
        __pyx_t_3 = 0;

+3354:                 plt.axvline(x=delta_theta_solution, color='green', linestyle='--', label=f"Theta Ans Converged at {delta_theta_solution:.2f}")

      __pyx_t_8 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3354, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_axvline); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3354, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_PyObject_Format(__pyx_v_delta_theta_solution, __pyx_mstate_global->__pyx_kp_u_2f); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3354, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Theta_Ans_Converged_at, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3354, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_8);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_8, NULL};
        __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3354, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_x, __pyx_v_delta_theta_solution, __pyx_t_10, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3354, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_green, __pyx_t_10, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 3354, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_linestyle, __pyx_mstate_global->__pyx_kp_u__15, __pyx_t_10, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 3354, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_t_2, __pyx_t_10, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 3354, __pyx_L1_error)
        __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_6, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3354, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 3355:             else:

 3356:                 pass

+3357:                 print('Root finder gave up, rip')

    /*else*/ {
      __pyx_t_6 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_10 = __pyx_builtin_print; 
      __pyx_t_5 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_Root_finder_gave_up_rip};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3357, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __pyx_L5:;

 3358: 

 3359:         # Add a horizontal line at y=0

+3360:         plt.axhline(y=0, color='black', linewidth=1.5, label="y=0")

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3360, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_axhline); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3360, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_3, NULL};
    __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3360, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_y, __pyx_mstate_global->__pyx_int_0, __pyx_t_10, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3360, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_color, __pyx_mstate_global->__pyx_n_u_black, __pyx_t_10, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 3360, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_linewidth, __pyx_mstate_global->__pyx_float_1_5, __pyx_t_10, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 3360, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_mstate_global->__pyx_kp_u_y_0, __pyx_t_10, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 3360, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_6, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3360, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 3361: 

+3362:         plt.xlabel("Theta")

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_xlabel); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Theta};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3362, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3363:         plt.ylabel("Values")

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ylabel); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3363, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Values};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3363, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3364:         plt.title("Function and Derivatives Plot")

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_title); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_Function_and_Derivatives_Plot};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3364, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3365:         plt.grid(True)

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3365, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3365, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, Py_True};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3365, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3366:         plt.legend()

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3366, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_legend); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3366, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_10))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_10);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3366, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 3367: 

+3368:         plt.tight_layout()

  __pyx_t_10 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3368, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_tight_layout); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3368, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_10);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3368, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3369:         plt.show()

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_show); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3369, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 3370: 

 3371:     # plot_function()

 3372:     #valid_solutions = []

 3373:     # print_debug = False

+3374:     amount_we_can_turn_before_we_can_shoot_rad = float(timesteps_until_can_fire)*SHIP_MAX_TURN_RATE_RAD_TS

  __pyx_t_6 = PyLong_AsDouble(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3374, __pyx_L1_error)
  __pyx_t_3 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_RAD_TS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_amount_we_can_turn_before_we_can_shoot_rad = __pyx_t_4;
  __pyx_t_4 = 0;

+3375:     naive_solution = naive_desired_heading_calc(timesteps_until_can_fire)

  __pyx_t_4 = __pyx_cur_scope->__pyx_v_timesteps_until_can_fire;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_5 = __pyx_pf_14neo_controller_18solve_interception_naive_desired_heading_calc(__pyx_cur_scope->__pyx_v_naive_desired_heading_calc, ((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3375, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_naive_solution = __pyx_t_5;
  __pyx_t_5 = 0;

 3376:     # naive_solution is this tuple: (interception time in seconds from firing to hit, delta theta rad, timesteps until fire, None, intercept_x, intercept_y, None)

 3377:     # debug_print("Evaluating naive solution:", naive_solution)

+3378:     if abs(naive_solution[1]) <= amount_we_can_turn_before_we_can_shoot_rad + EPS:

  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_naive_solution, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyNumber_Absolute(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = PyNumber_Add(__pyx_v_amount_we_can_turn_before_we_can_shoot_rad, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3378, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3378, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_8) {
/* … */
    goto __pyx_L3;
  }

 3379:         # The naive solution works because there's no turning delay

 3380:         # debug_print('Naive solution works!', naive_solution)

+3381:         if check_coordinate_bounds(game_state, naive_solution[3], naive_solution[4]):

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3381, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_naive_solution, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3381, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_naive_solution, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3381, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_3, ((PyObject *)__pyx_v_game_state), __pyx_t_1, __pyx_t_9};
      __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3381, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3381, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_8) {
/* … */
    }

 3382:             # Tuple is: (feasible, shooting_angle_error_deg, aiming_timesteps_required, interception_time_s, intercept_x, intercept_y, asteroid_dist_during_interception)

+3383:             return True, degrees(naive_solution[1]), timesteps_until_can_fire, naive_solution[0], naive_solution[3], naive_solution[4], naive_solution[5]

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_4 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3383, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_naive_solution, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3383, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_4);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_1};
        __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3383, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_naive_solution, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3383, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_naive_solution, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3383, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_naive_solution, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3383, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_naive_solution, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3383, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_10 = PyTuple_New(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3383, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_INCREF(Py_True);
      __Pyx_GIVEREF(Py_True);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, Py_True) != (0)) __PYX_ERR(0, 3383, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_5);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 3383, __pyx_L1_error);
      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire);
      __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_cur_scope->__pyx_v_timesteps_until_can_fire) != (0)) __PYX_ERR(0, 3383, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_9);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 3, __pyx_t_9) != (0)) __PYX_ERR(0, 3383, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 4, __pyx_t_1) != (0)) __PYX_ERR(0, 3383, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 5, __pyx_t_4) != (0)) __PYX_ERR(0, 3383, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 6, __pyx_t_3) != (0)) __PYX_ERR(0, 3383, __pyx_L1_error);
      __pyx_t_5 = 0;
      __pyx_t_9 = 0;
      __pyx_t_1 = 0;
      __pyx_t_4 = 0;
      __pyx_t_3 = 0;
      __pyx_r = ((PyObject*)__pyx_t_10);
      __pyx_t_10 = 0;
      goto __pyx_L0;

 3384:     else:

+3385:         if abs(avx) < GRAIN and abs(avy) < GRAIN:

  /*else*/ {
    __pyx_t_6 = fabs(__pyx_cur_scope->__pyx_v_avx); 
    __pyx_t_11 = (__pyx_t_6 < __pyx_v_14neo_controller_GRAIN);
    if (__pyx_t_11) {
    } else {
      __pyx_t_8 = __pyx_t_11;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_6 = fabs(__pyx_cur_scope->__pyx_v_avy); 
    __pyx_t_11 = (__pyx_t_6 < __pyx_v_14neo_controller_GRAIN);
    __pyx_t_8 = __pyx_t_11;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_8) {
/* … */
      goto __pyx_L5;
    }

 3386:             # The asteroid is pretty much stationary. Naive solution works fine.

 3387:             # debug_print("The asteroid is pretty much stationary. Naive solution works fine.")

+3388:             delta_theta_solution = naive_solution[1]

      __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_naive_solution, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3388, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_v_delta_theta_solution = __pyx_t_10;
      __pyx_t_10 = 0;

 3389:         else:

 3390:             # Use more advanced solution

 3391:             # debug_print('Using more advanced root finder')

+3392:             delta_theta_solution = turbo_rootinator_5000(naive_solution[1], TAD, 4)  # root_function, root_function_derivative, root_function_second_derivative

    /*else*/ {
      __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_naive_solution, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3392, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_10); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3392, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __pyx_pf_14neo_controller_18solve_interception_14turbo_rootinator_5000(__pyx_cur_scope->__pyx_v_turbo_rootinator_5000, __pyx_t_6, __pyx_v_14neo_controller_TAD, __pyx_mstate_global->__pyx_int_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3392, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_v_delta_theta_solution = __pyx_t_10;
      __pyx_t_10 = 0;
    }
    __pyx_L5:;

 3393:             # debug_print('Root finder gave us:', sol)

+3394:         if isnan(delta_theta_solution):

    __pyx_t_12 = __Pyx_PyFloat_AsDouble(__pyx_v_delta_theta_solution); if (unlikely((__pyx_t_12 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3394, __pyx_L1_error)
    __pyx_t_8 = isnan(__pyx_t_12);
    if (__pyx_t_8) {
/* … */
    }

+3395:             return False, NAN, -1, NAN, NAN, NAN, NAN

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_10 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_9 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = PyTuple_New(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, Py_False) != (0)) __PYX_ERR(0, 3395, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_10);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 3395, __pyx_L1_error);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
      __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 3395, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3) != (0)) __PYX_ERR(0, 3395, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_4);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_4) != (0)) __PYX_ERR(0, 3395, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_t_1) != (0)) __PYX_ERR(0, 3395, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_9);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __pyx_t_9) != (0)) __PYX_ERR(0, 3395, __pyx_L1_error);
      __pyx_t_10 = 0;
      __pyx_t_3 = 0;
      __pyx_t_4 = 0;
      __pyx_t_1 = 0;
      __pyx_t_9 = 0;
      __pyx_r = ((PyObject*)__pyx_t_5);
      __pyx_t_5 = 0;
      goto __pyx_L0;

+3396:         absolute_theta_solution = delta_theta_solution + theta_0

    __pyx_t_5 = PyNumber_Add(__pyx_v_delta_theta_solution, __pyx_cur_scope->__pyx_v_theta_0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3396, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_v_absolute_theta_solution = __pyx_t_5;
    __pyx_t_5 = 0;

+3397:         assert -pi <= delta_theta_solution <= pi  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_5 = PyFloat_FromDouble((-M_PI)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3397, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_9 = PyObject_RichCompare(__pyx_t_5, __pyx_v_delta_theta_solution, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3397, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_9)) {
        __Pyx_DECREF(__pyx_t_9);
        __pyx_t_1 = PyFloat_FromDouble(M_PI); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3397, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_9 = PyObject_RichCompare(__pyx_v_delta_theta_solution, __pyx_t_1, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3397, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3397, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_8)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 3397, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 3397, __pyx_L1_error)
    #endif

 3398:         # if not (-pi <= delta_theta_solution <= pi):

 3399:             # debug_print(f"SOLUTION WAS OUT OUT BOUNDS AT {delta_theta_solution} AND WRAPPED TO -pi, pi")

 3400:             # delta_theta_solution = (delta_theta_solution + pi)%TAU - pi

 3401:         # Check validity of solution to make sure time is positive and stuff

+3402:         delta_theta_solution_deg = degrees(delta_theta_solution)

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3402, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_delta_theta_solution};
      __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3402, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __pyx_v_delta_theta_solution_deg = __pyx_t_9;
    __pyx_t_9 = 0;

+3403:         t_rot = rotation_time(delta_theta_solution)

    __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_v_delta_theta_solution); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3403, __pyx_L1_error)
    __pyx_t_9 = __pyx_pf_14neo_controller_18solve_interception_16rotation_time(__pyx_cur_scope->__pyx_v_rotation_time, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3403, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_v_t_rot = __pyx_t_9;
    __pyx_t_9 = 0;

+3404:         assert is_close(t_rot, abs(delta_theta_solution_deg)/SHIP_MAX_TURN_RATE)  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3404, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyNumber_Absolute(__pyx_v_delta_theta_solution_deg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3404, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3404, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3404, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_t_rot, __pyx_t_10};
        __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3404, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3404, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_8)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 3404, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 3404, __pyx_L1_error)
    #endif

+3405:         t_bullet = bullet_travel_time(delta_theta_solution, t_rot)

    __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_v_delta_theta_solution); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3405, __pyx_L1_error)
    __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_t_rot); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3405, __pyx_L1_error)
    __pyx_t_9 = __pyx_pf_14neo_controller_18solve_interception_18bullet_travel_time(__pyx_v_bullet_travel_time, __pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3405, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_v_t_bullet = __pyx_t_9;
    __pyx_t_9 = 0;

 3406:         # debug_print(f't_bullet: {t_bullet}')

+3407:         if t_bullet < 0:

    __pyx_t_9 = PyObject_RichCompare(__pyx_v_t_bullet, __pyx_mstate_global->__pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3407, __pyx_L1_error)
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3407, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_8) {
/* … */
    }

+3408:             return False, NAN, -1, NAN, NAN, NAN, NAN

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_9 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3408, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3408, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_10 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3408, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3408, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3408, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyTuple_New(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3408, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, Py_False) != (0)) __PYX_ERR(0, 3408, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_9);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 3408, __pyx_L1_error);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
      __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 3408, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_5);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_5) != (0)) __PYX_ERR(0, 3408, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_10);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_t_10) != (0)) __PYX_ERR(0, 3408, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_1);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_t_1) != (0)) __PYX_ERR(0, 3408, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_3);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 6, __pyx_t_3) != (0)) __PYX_ERR(0, 3408, __pyx_L1_error);
      __pyx_t_9 = 0;
      __pyx_t_5 = 0;
      __pyx_t_10 = 0;
      __pyx_t_1 = 0;
      __pyx_t_3 = 0;
      __pyx_r = ((PyObject*)__pyx_t_4);
      __pyx_t_4 = 0;
      goto __pyx_L0;

 3409:         # t_total = t_rot + t_bullet

 3410: 

+3411:         bullet_travel_dist = vb*(t_bullet + t_0)

    __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_t_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3411, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyNumber_Add(__pyx_v_t_bullet, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3411, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_Multiply(__pyx_cur_scope->__pyx_v_vb, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3411, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_bullet_travel_dist = __pyx_t_4;
    __pyx_t_4 = 0;

+3412:         intercept_x = origin_x + bullet_travel_dist*cos(absolute_theta_solution)

    __pyx_t_4 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_origin_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_absolute_theta_solution); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3412, __pyx_L1_error)
    __pyx_t_3 = PyFloat_FromDouble(cos(__pyx_t_13)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = PyNumber_Multiply(__pyx_v_bullet_travel_dist, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_intercept_x = __pyx_t_3;
    __pyx_t_3 = 0;

+3413:         intercept_y = origin_y + bullet_travel_dist*sin(absolute_theta_solution)

    __pyx_t_3 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_origin_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_absolute_theta_solution); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3413, __pyx_L1_error)
    __pyx_t_1 = PyFloat_FromDouble(sin(__pyx_t_13)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyNumber_Multiply(__pyx_v_bullet_travel_dist, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_intercept_y = __pyx_t_1;
    __pyx_t_1 = 0;

 3414:         # debug_print(f"Intercept_x ({intercept_x}) = origin_x ({origin_x}) + vb*cos({absolute_theta_solution})*(t_bullet ({t_bullet}) + t_0 ({t_0}))")

 3415:         # debug_print(f"Intercept_y ({intercept_y}) = origin_y ({origin_y}) + vb*sin({absolute_theta_solution})*(t_bullet ({t_bullet}) + t_0 ({t_0}))")

 3416: 

+3417:         if check_coordinate_bounds(game_state, intercept_x, intercept_y):

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3417, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_4, ((PyObject *)__pyx_v_game_state), __pyx_v_intercept_x, __pyx_v_intercept_y};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3417, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3417, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_8) {
/* … */
    }
  }
  __pyx_L3:;

 3418:             # debug_print(f"The coordinates of {intercept_x}, {intercept_y} are GUCCI! We'd have to turn this many ts: {t_rot*FPS}")

 3419:             # Since half timesteps don't exist, we need to discretize this solution by rounding up the amount of timesteps, and now we can use the naive method to confirm and get the exact angle

 3420:             # We max this with ts until can fire, because that's the floor and we can't go below it

+3421:             t_rot_ts = max(timesteps_until_can_fire, ceil(t_rot*FPS))

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ceil); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3421, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3421, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_5 = PyNumber_Multiply(__pyx_v_t_rot, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3421, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3421, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_timesteps_until_can_fire);
      __pyx_t_14 = __pyx_cur_scope->__pyx_v_timesteps_until_can_fire;
      __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_14, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3421, __pyx_L1_error)
      __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3421, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_8) {
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1;
      } else {
        __Pyx_INCREF(__pyx_t_14);
        __pyx_t_4 = __pyx_t_14;
      }
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __pyx_t_4;
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_v_t_rot_ts = __pyx_t_1;
      __pyx_t_1 = 0;

+3422:             print(t_rot_ts)

      __pyx_t_4 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_5 = __pyx_builtin_print; 
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_t_rot_ts};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3422, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3423:             print(type(t_rot_ts))

      __pyx_t_5 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_4 = __pyx_builtin_print; 
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)Py_TYPE(__pyx_v_t_rot_ts))};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3423, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 3424:             # debug_print(f"The rotation timesteps we've calculated is {t_rot_ts}, from a t_rot of {t_rot}")

 3425:             # valid_solutions.append((True, delta_theta_solution_deg, t_rot_ts, None, intercept_x, intercept_y, None))

+3426:             discrete_solution = naive_desired_heading_calc(t_rot_ts)

      if (!(likely(PyLong_CheckExact(__pyx_v_t_rot_ts))||((__pyx_v_t_rot_ts) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_v_t_rot_ts))) __PYX_ERR(0, 3426, __pyx_L1_error)
      __pyx_t_1 = __pyx_pf_14neo_controller_18solve_interception_naive_desired_heading_calc(__pyx_cur_scope->__pyx_v_naive_desired_heading_calc, ((PyObject*)__pyx_v_t_rot_ts)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3426, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_v_discrete_solution = __pyx_t_1;
      __pyx_t_1 = 0;

+3427:             if not isnan(discrete_solution[0]):

      __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3427, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_12 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_12 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3427, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_8 = (!isnan(__pyx_t_12));
      if (__pyx_t_8) {
/* … */
      }

+3428:                 if not abs(degrees(discrete_solution[1])) - EPS <= float(t_rot_ts)*SHIP_MAX_TURN_RATE_DEG_TS:

        __pyx_t_4 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_7 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_5))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
          assert(__pyx_t_4);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
          __pyx_t_7 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
          __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3428, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = PyNumber_Subtract(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyNumber_Float(__pyx_v_t_rot_ts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE_DEG_TS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3428, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_11 = (!__pyx_t_8);
        if (__pyx_t_11) {
/* … */
        }

+3429:                     return False, NAN, -1, NAN, NAN, NAN, NAN

          __Pyx_XDECREF(__pyx_r);
          __pyx_t_5 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3429, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_4 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3429, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3429, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3429, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_10 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3429, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_9 = PyTuple_New(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3429, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_INCREF(Py_False);
          __Pyx_GIVEREF(Py_False);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, Py_False) != (0)) __PYX_ERR(0, 3429, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_5);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 3429, __pyx_L1_error);
          __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
          __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 3429, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_4);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 3429, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_3);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 4, __pyx_t_3) != (0)) __PYX_ERR(0, 3429, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_1);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 5, __pyx_t_1) != (0)) __PYX_ERR(0, 3429, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_10);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 6, __pyx_t_10) != (0)) __PYX_ERR(0, 3429, __pyx_L1_error);
          __pyx_t_5 = 0;
          __pyx_t_4 = 0;
          __pyx_t_3 = 0;
          __pyx_t_1 = 0;
          __pyx_t_10 = 0;
          __pyx_r = ((PyObject*)__pyx_t_9);
          __pyx_t_9 = 0;
          goto __pyx_L0;

+3430:                 assert t_rot_ts == discrete_solution[2]  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3430, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_10 = PyObject_RichCompare(__pyx_v_t_rot_ts, __pyx_t_9, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3430, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 3430, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_11)) {
            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
            __PYX_ERR(0, 3430, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 3430, __pyx_L1_error)
        #endif

+3431:                 if check_coordinate_bounds(game_state, discrete_solution[3], discrete_solution[4]):

        __pyx_t_9 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_7 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_1))) {
          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1);
          assert(__pyx_t_9);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
          __Pyx_INCREF(__pyx_t_9);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
          __pyx_t_7 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_9, ((PyObject *)__pyx_v_game_state), __pyx_t_3, __pyx_t_4};
          __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3431, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
        }
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 3431, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (__pyx_t_11) {
/* … */
        }

 3432:                     # debug_print('Valid solution found!', disc_sol)

+3433:                     return True, degrees(discrete_solution[1]), t_rot_ts, discrete_solution[0], discrete_solution[3], discrete_solution[4], discrete_solution[5]

          __Pyx_XDECREF(__pyx_r);
          __pyx_t_1 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3433, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3433, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_4))) {
            __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
            assert(__pyx_t_1);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
            __Pyx_INCREF(__pyx_t_1);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3};
            __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3433, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
          }
          __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3433, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3433, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3433, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_discrete_solution, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3433, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_5 = PyTuple_New(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3433, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_INCREF(Py_True);
          __Pyx_GIVEREF(Py_True);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, Py_True) != (0)) __PYX_ERR(0, 3433, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_10);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 3433, __pyx_L1_error);
          __Pyx_INCREF(__pyx_v_t_rot_ts);
          __Pyx_GIVEREF(__pyx_v_t_rot_ts);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_t_rot_ts) != (0)) __PYX_ERR(0, 3433, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_4);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 3433, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_3);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_3) != (0)) __PYX_ERR(0, 3433, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_1);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_t_1) != (0)) __PYX_ERR(0, 3433, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_9);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __pyx_t_9) != (0)) __PYX_ERR(0, 3433, __pyx_L1_error);
          __pyx_t_10 = 0;
          __pyx_t_4 = 0;
          __pyx_t_3 = 0;
          __pyx_t_1 = 0;
          __pyx_t_9 = 0;
          __pyx_r = ((PyObject*)__pyx_t_5);
          __pyx_t_5 = 0;
          goto __pyx_L0;

 3434: 

+3435:     return False, NAN, -1, NAN, NAN, NAN, NAN

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3435, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3435, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3435, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3435, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3435, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = PyTuple_New(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3435, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_INCREF(Py_False);
  __Pyx_GIVEREF(Py_False);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, Py_False) != (0)) __PYX_ERR(0, 3435, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 3435, __pyx_L1_error);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 3435, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_9);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 3, __pyx_t_9) != (0)) __PYX_ERR(0, 3435, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 4, __pyx_t_1) != (0)) __PYX_ERR(0, 3435, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 5, __pyx_t_3) != (0)) __PYX_ERR(0, 3435, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 6, __pyx_t_4) != (0)) __PYX_ERR(0, 3435, __pyx_L1_error);
  __pyx_t_5 = 0;
  __pyx_t_9 = 0;
  __pyx_t_1 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = ((PyObject*)__pyx_t_10);
  __pyx_t_10 = 0;
  goto __pyx_L0;

 3436:     # The returned interception time is the time AFTER FIRING! NOT INCLUDING TURNING!

 3437:     # return (feasible, shooting_angle_error_deg, aiming_timesteps_required, interception_time_s, intercept_x, intercept_y, asteroid_dist_during_interception)

 3438: 

 3439: 

+3440: def track_asteroid_we_shot_at(asteroids_pending_death: dict[int, list[Asteroid]], current_timestep: int, game_state: GameState, bullet_travel_timesteps: int, original_asteroid: Asteroid) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_139track_asteroid_we_shot_at(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_139track_asteroid_we_shot_at = {"track_asteroid_we_shot_at", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_139track_asteroid_we_shot_at, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_139track_asteroid_we_shot_at(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_asteroids_pending_death = 0;
  PyObject *__pyx_v_current_timestep = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  PyObject *__pyx_v_bullet_travel_timesteps = 0;
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_original_asteroid = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("track_asteroid_we_shot_at (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroids_pending_death,&__pyx_mstate_global->__pyx_n_u_current_timestep,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_bullet_travel_timesteps,&__pyx_mstate_global->__pyx_n_u_original_asteroid,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3440, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3440, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3440, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3440, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3440, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3440, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "track_asteroid_we_shot_at", 0) < 0) __PYX_ERR(0, 3440, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 5; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("track_asteroid_we_shot_at", 1, 5, 5, i); __PYX_ERR(0, 3440, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 5)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3440, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3440, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3440, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3440, __pyx_L3_error)
      values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3440, __pyx_L3_error)
    }
    __pyx_v_asteroids_pending_death = ((PyObject*)values[0]);
    __pyx_v_current_timestep = ((PyObject*)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
    __pyx_v_bullet_travel_timesteps = ((PyObject*)values[3]);
    __pyx_v_original_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[4]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("track_asteroid_we_shot_at", 1, 5, 5, __pyx_nargs); __PYX_ERR(0, 3440, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.track_asteroid_we_shot_at", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids_pending_death), (&PyDict_Type), 0, "asteroids_pending_death", 2))) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_current_timestep), (&PyLong_Type), 0, "current_timestep", 2))) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bullet_travel_timesteps), (&PyLong_Type), 0, "bullet_travel_timesteps", 2))) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_original_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "original_asteroid", 0))) __PYX_ERR(0, 3440, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_138track_asteroid_we_shot_at(__pyx_self, __pyx_v_asteroids_pending_death, __pyx_v_current_timestep, __pyx_v_game_state, __pyx_v_bullet_travel_timesteps, __pyx_v_original_asteroid);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_138track_asteroid_we_shot_at(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_asteroids_pending_death, PyObject *__pyx_v_current_timestep, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, PyObject *__pyx_v_bullet_travel_timesteps, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_original_asteroid) {
  PyObject *__pyx_v_asteroid = NULL;
  PyObject *__pyx_v_future_timesteps = NULL;
  PyObject *__pyx_v_timestep = NULL;
  PyObject *__pyx_v_culled_asteroids_pending_death = NULL;
  PyObject *__pyx_9genexpr19__pyx_v_k = NULL;
  PyObject *__pyx_9genexpr19__pyx_v_v = NULL;
  PyObject *__pyx_9genexpr20__pyx_v_a = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_AddTraceback("neo_controller.track_asteroid_we_shot_at", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_v_future_timesteps);
  __Pyx_XDECREF(__pyx_v_timestep);
  __Pyx_XDECREF(__pyx_v_culled_asteroids_pending_death);
  __Pyx_XDECREF(__pyx_9genexpr19__pyx_v_k);
  __Pyx_XDECREF(__pyx_9genexpr19__pyx_v_v);
  __Pyx_XDECREF(__pyx_9genexpr20__pyx_v_a);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3440, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_mstate_global->__pyx_kp_u_dict_int_list_Asteroid) < 0) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bullet_travel_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_original_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3440, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 3440, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_139track_asteroid_we_shot_at, 0, __pyx_mstate_global->__pyx_n_u_track_asteroid_we_shot_at, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[142])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3440, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_track_asteroid_we_shot_at, __pyx_t_2) < 0) __PYX_ERR(0, 3440, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3441:     #global asteroid_tracking_total_time

 3442:     #start_time = time.perf_counter()

 3443:     # This modifies asteroids_pending_death in place instead of returning it

 3444:     # Make a copy of the asteroid so we don't mess up the original object

+3445:     asteroid = original_asteroid.copy()

  __pyx_t_2 = ((PyObject *)__pyx_v_original_asteroid);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3445, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_asteroid = __pyx_t_1;
  __pyx_t_1 = 0;

 3446:     # Wrap asteroid position

+3447:     asteroid.position = (asteroid.position[0] % game_state.map_size[0], asteroid.position[1] % game_state.map_size[1])

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyNumber_Remainder(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Remainder(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 3447, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 3447, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position, __pyx_t_5) < 0) __PYX_ERR(0, 3447, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 3448:     # Project the asteroid into the future, to where it would be on the timestep of its death

 3449: 

+3450:     for future_timesteps in range(0, bullet_travel_timesteps + 1):

  __pyx_t_4 = NULL;
  __Pyx_INCREF(__pyx_builtin_range);
  __pyx_t_1 = __pyx_builtin_range; 
  __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_v_bullet_travel_timesteps, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3450, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_mstate_global->__pyx_int_0, __pyx_t_2};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3450, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) {
    __pyx_t_1 = __pyx_t_5; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_6 = 0;
    __pyx_t_7 = NULL;
  } else {
    __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3450, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3450, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  for (;;) {
    if (likely(!__pyx_t_7)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3450, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_6);
        ++__pyx_t_6;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3450, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6));
        #else
        __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6);
        #endif
        ++__pyx_t_6;
      }
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3450, __pyx_L1_error)
    } else {
      __pyx_t_5 = __pyx_t_7(__pyx_t_1);
      if (unlikely(!__pyx_t_5)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3450, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_5);
    if (!(likely(PyLong_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_5))) __PYX_ERR(0, 3450, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v_future_timesteps, ((PyObject*)__pyx_t_5));
    __pyx_t_5 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3451:         timestep = current_timestep + future_timesteps

    __pyx_t_5 = PyNumber_Add(__pyx_v_current_timestep, __pyx_v_future_timesteps); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_timestep, ((PyObject*)__pyx_t_5));
    __pyx_t_5 = 0;

+3452:         if timestep not in asteroids_pending_death:

    __pyx_t_8 = (__Pyx_PyDict_ContainsTF(__pyx_v_timestep, __pyx_v_asteroids_pending_death, Py_NE)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3452, __pyx_L1_error)
    if (__pyx_t_8) {
/* … */
      goto __pyx_L5;
    }

+3453:             asteroids_pending_death[timestep] = [asteroid.copy()]

      __pyx_t_2 = __pyx_v_asteroid;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_3 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3453, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3453, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_GIVEREF(__pyx_t_5);
      if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 3453, __pyx_L1_error);
      __pyx_t_5 = 0;
      if (unlikely((PyDict_SetItem(__pyx_v_asteroids_pending_death, __pyx_v_timestep, __pyx_t_2) < 0))) __PYX_ERR(0, 3453, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3454:         else:

+3455:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    /*else*/ {
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3455, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3455, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (__pyx_t_8) {
/* … */
      }

+3456:                 if is_asteroid_in_list(asteroids_pending_death[timestep], asteroid, game_state):  # REMOVE_FOR_COMPETITION

        __pyx_t_5 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_is_asteroid_in_list); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3456, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_9 = __Pyx_PyDict_GetItem(__pyx_v_asteroids_pending_death, __pyx_v_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3456, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_3 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_5);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_3 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_t_9, __pyx_v_asteroid, ((PyObject *)__pyx_v_game_state)};
          __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_3, (4-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3456, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (__pyx_t_8) {
/* … */
        }

+3457:                     print(f'ABOUT TO FAIL ASSERTION, we are in the future by {future_timesteps} timesteps from the current ts {current_timestep}, this asteroid is {asteroid} and LIST FOR THIS TS IS:')  # REMOVE_FOR_COMPETITION

          __pyx_t_4 = NULL;
          __Pyx_INCREF(__pyx_builtin_print);
          __pyx_t_9 = __pyx_builtin_print; 
          __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_future_timesteps, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3457, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_current_timestep, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3457, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_v_asteroid, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3457, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_11);
          __pyx_t_12[0] = __pyx_mstate_global->__pyx_kp_u_ABOUT_TO_FAIL_ASSERTION_we_are_i;
          __pyx_t_12[1] = __pyx_t_5;
          __pyx_t_12[2] = __pyx_mstate_global->__pyx_kp_u_timesteps_from_the_current_ts;
          __pyx_t_12[3] = __pyx_t_10;
          __pyx_t_12[4] = __pyx_mstate_global->__pyx_kp_u_this_asteroid_is;
          __pyx_t_12[5] = __pyx_t_11;
          __pyx_t_12[6] = __pyx_mstate_global->__pyx_kp_u_and_LIST_FOR_THIS_TS_IS;
          __pyx_t_13 = __Pyx_PyUnicode_Join(__pyx_t_12, 7, 49 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 31 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 19 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_11) + 25, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_11));
          if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3457, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          __pyx_t_3 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_13};
            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3457, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
          }
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3458:                     print(asteroids_pending_death[timestep])  # REMOVE_FOR_COMPETITION

          __pyx_t_9 = NULL;
          __Pyx_INCREF(__pyx_builtin_print);
          __pyx_t_13 = __pyx_builtin_print; 
          __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_asteroids_pending_death, __pyx_v_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3458, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_3 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_4};
            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3458, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
          }
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3459:                     culled_asteroids_pending_death = {k: [a for a in v if is_close(a.velocity[0], -10.0)] for k, v in asteroids_pending_death.items()}  # REMOVE_FOR_COMPETITION

          { /* enter inner scope */
            __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3459, __pyx_L10_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_14 = 0;
            __pyx_t_4 = __Pyx_dict_iterator(__pyx_v_asteroids_pending_death, 1, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_15), (&__pyx_t_16)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3459, __pyx_L10_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_XDECREF(__pyx_t_13);
            __pyx_t_13 = __pyx_t_4;
            __pyx_t_4 = 0;
            while (1) {
              __pyx_t_17 = __Pyx_dict_iter_next(__pyx_t_13, __pyx_t_15, &__pyx_t_14, &__pyx_t_4, &__pyx_t_9, NULL, __pyx_t_16);
              if (unlikely(__pyx_t_17 == 0)) break;
              if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 3459, __pyx_L10_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_GOTREF(__pyx_t_9);
              __Pyx_XDECREF_SET(__pyx_9genexpr19__pyx_v_k, __pyx_t_4);
              __pyx_t_4 = 0;
              __Pyx_XDECREF_SET(__pyx_9genexpr19__pyx_v_v, __pyx_t_9);
              __pyx_t_9 = 0;
              { /* enter inner scope */
                __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3459, __pyx_L15_error)
                __Pyx_GOTREF(__pyx_t_9);
                if (likely(PyList_CheckExact(__pyx_9genexpr19__pyx_v_v)) || PyTuple_CheckExact(__pyx_9genexpr19__pyx_v_v)) {
                  __pyx_t_4 = __pyx_9genexpr19__pyx_v_v; __Pyx_INCREF(__pyx_t_4);
                  __pyx_t_18 = 0;
                  __pyx_t_19 = NULL;
                } else {
                  __pyx_t_18 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_9genexpr19__pyx_v_v); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3459, __pyx_L15_error)
                  __Pyx_GOTREF(__pyx_t_4);
                  __pyx_t_19 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 3459, __pyx_L15_error)
                }
                for (;;) {
                  if (likely(!__pyx_t_19)) {
                    if (likely(PyList_CheckExact(__pyx_t_4))) {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3459, __pyx_L15_error)
                        #endif
                        if (__pyx_t_18 >= __pyx_temp) break;
                      }
                      __pyx_t_11 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_18);
                      ++__pyx_t_18;
                    } else {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3459, __pyx_L15_error)
                        #endif
                        if (__pyx_t_18 >= __pyx_temp) break;
                      }
                      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                      __pyx_t_11 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_18));
                      #else
                      __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_18);
                      #endif
                      ++__pyx_t_18;
                    }
                    if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3459, __pyx_L15_error)
                  } else {
                    __pyx_t_11 = __pyx_t_19(__pyx_t_4);
                    if (unlikely(!__pyx_t_11)) {
                      PyObject* exc_type = PyErr_Occurred();
                      if (exc_type) {
                        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3459, __pyx_L15_error)
                        PyErr_Clear();
                      }
                      break;
                    }
                  }
                  __Pyx_GOTREF(__pyx_t_11);
                  __Pyx_XDECREF_SET(__pyx_9genexpr20__pyx_v_a, __pyx_t_11);
                  __pyx_t_11 = 0;
                  __pyx_t_10 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3459, __pyx_L15_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr20__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3459, __pyx_L15_error)
                  __Pyx_GOTREF(__pyx_t_20);
                  __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_20, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 3459, __pyx_L15_error)
                  __Pyx_GOTREF(__pyx_t_21);
                  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
                  __pyx_t_3 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_5))) {
                    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5);
                    assert(__pyx_t_10);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
                    __Pyx_INCREF(__pyx_t_10);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
                    __pyx_t_3 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_21, __pyx_mstate_global->__pyx_float_neg_10_0};
                    __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
                    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3459, __pyx_L15_error)
                    __Pyx_GOTREF(__pyx_t_11);
                  }
                  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3459, __pyx_L15_error)
                  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                  if (__pyx_t_8) {
                    if (unlikely(__Pyx_ListComp_Append(__pyx_t_9, (PyObject*)__pyx_9genexpr20__pyx_v_a))) __PYX_ERR(0, 3459, __pyx_L15_error)
                  }
                }
                __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                __Pyx_XDECREF(__pyx_9genexpr20__pyx_v_a); __pyx_9genexpr20__pyx_v_a = 0;
                goto __pyx_L20_exit_scope;
                __pyx_L15_error:;
                __Pyx_XDECREF(__pyx_9genexpr20__pyx_v_a); __pyx_9genexpr20__pyx_v_a = 0;
                goto __pyx_L10_error;
                __pyx_L20_exit_scope:;
              } /* exit inner scope */
              if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_9genexpr19__pyx_v_k, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 3459, __pyx_L10_error)
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            }
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_XDECREF(__pyx_9genexpr19__pyx_v_k); __pyx_9genexpr19__pyx_v_k = 0;
            __Pyx_XDECREF(__pyx_9genexpr19__pyx_v_v); __pyx_9genexpr19__pyx_v_v = 0;
            goto __pyx_L21_exit_scope;
            __pyx_L10_error:;
            __Pyx_XDECREF(__pyx_9genexpr19__pyx_v_k); __pyx_9genexpr19__pyx_v_k = 0;
            __Pyx_XDECREF(__pyx_9genexpr19__pyx_v_v); __pyx_9genexpr19__pyx_v_v = 0;
            goto __pyx_L1_error;
            __pyx_L21_exit_scope:;
          } /* exit inner scope */
          __Pyx_XDECREF_SET(__pyx_v_culled_asteroids_pending_death, ((PyObject*)__pyx_t_2));
          __pyx_t_2 = 0;

+3460:                     print(culled_asteroids_pending_death)  # REMOVE_FOR_COMPETITION

          __pyx_t_13 = NULL;
          __Pyx_INCREF(__pyx_builtin_print);
          __pyx_t_9 = __pyx_builtin_print; 
          __pyx_t_3 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_v_culled_asteroids_pending_death};
            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3460, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
          }
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3461:                 assert not is_asteroid_in_list(asteroids_pending_death[timestep], asteroid, game_state), f"The asteroid {asteroid} appeared in the list of pending death when it wasn't supposed to! I'm on future ts {future_timesteps} when tracking."  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_9 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_is_asteroid_in_list); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3461, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_asteroids_pending_death, __pyx_v_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3461, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_3 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_13))) {
            __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_13);
            assert(__pyx_t_9);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
            __Pyx_INCREF(__pyx_t_9);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
            __pyx_t_3 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_9, __pyx_t_4, __pyx_v_asteroid, ((PyObject *)__pyx_v_game_state)};
            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_3, (4-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3461, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
          }
          __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3461, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_22 = (!__pyx_t_8);
          if (unlikely(!__pyx_t_22)) {
            __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_asteroid, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3461, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_future_timesteps, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3461, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            __pyx_t_23[0] = __pyx_mstate_global->__pyx_kp_u_The_asteroid;
            __pyx_t_23[1] = __pyx_t_2;
            __pyx_t_23[2] = __pyx_mstate_global->__pyx_kp_u_appeared_in_the_list_of_pending;
            __pyx_t_23[3] = __pyx_t_13;
            __pyx_t_23[4] = __pyx_mstate_global->__pyx_kp_u_when_tracking;
            __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_23, 5, 13 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 84 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13) + 15, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_13));
            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3461, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_4, 0, 0);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __PYX_ERR(0, 3461, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 3461, __pyx_L1_error)
        #endif

+3462:             asteroids_pending_death[timestep].append(asteroid.copy())

      __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_asteroids_pending_death, __pyx_v_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3462, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __pyx_v_asteroid;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_3 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
        __pyx_t_13 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3462, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
      }
      __pyx_t_24 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_13); if (unlikely(__pyx_t_24 == ((int)-1))) __PYX_ERR(0, 3462, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    }
    __pyx_L5:;

 3463:         # Advance the asteroid to the next position

+3464:         if future_timesteps != bullet_travel_timesteps:

    __pyx_t_13 = PyObject_RichCompare(__pyx_v_future_timesteps, __pyx_v_bullet_travel_timesteps, Py_NE); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3464, __pyx_L1_error)
    __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 3464, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (__pyx_t_22) {
/* … */
    }

 3465:             # Skip this operation on the last for loop iteration

+3466:             asteroid.position = ((asteroid.position[0] + asteroid.velocity[0]*DELTA_TIME) % game_state.map_size[0], (asteroid.position[1] + asteroid.velocity[1]*DELTA_TIME) % game_state.map_size[1])

      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_9 = PyNumber_Multiply(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = PyNumber_Add(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyNumber_Remainder(__pyx_t_13, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_11 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyNumber_Add(__pyx_t_13, __pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_11, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = PyNumber_Remainder(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_GIVEREF(__pyx_t_9);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_9) != (0)) __PYX_ERR(0, 3466, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_11);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_11) != (0)) __PYX_ERR(0, 3466, __pyx_L1_error);
      __pyx_t_9 = 0;
      __pyx_t_11 = 0;
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position, __pyx_t_13) < 0) __PYX_ERR(0, 3466, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 3467:     #asteroid_tracking_total_time += time.perf_counter() - start_time

 3468: 

 3469: 

+3470: def check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(asteroids_pending_death: dict[int, list[Asteroid]], current_timestep: int, game_state: GameState, asteroid: Asteroid) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_141check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_141check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot = {"check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_141check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_141check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_asteroids_pending_death = 0;
  PyObject *__pyx_v_current_timestep = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroids_pending_death,&__pyx_mstate_global->__pyx_n_u_current_timestep,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_asteroid,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3470, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3470, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3470, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3470, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3470, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot", 0) < 0) __PYX_ERR(0, 3470, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot", 1, 4, 4, i); __PYX_ERR(0, 3470, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3470, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3470, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3470, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3470, __pyx_L3_error)
    }
    __pyx_v_asteroids_pending_death = ((PyObject*)values[0]);
    __pyx_v_current_timestep = ((PyObject*)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 3470, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids_pending_death), (&PyDict_Type), 0, "asteroids_pending_death", 2))) __PYX_ERR(0, 3470, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_current_timestep), (&PyLong_Type), 0, "current_timestep", 2))) __PYX_ERR(0, 3470, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3470, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 3470, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_140check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(__pyx_self, __pyx_v_asteroids_pending_death, __pyx_v_current_timestep, __pyx_v_game_state, __pyx_v_asteroid);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_140check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_asteroids_pending_death, PyObject *__pyx_v_current_timestep, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot *__pyx_cur_scope;
  PyObject *__pyx_v_verify_asteroid_does_not_appear_in_wrong_timestep = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot *)__pyx_tp_new_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 3470, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_asteroids_pending_death = __pyx_v_asteroids_pending_death;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_asteroids_pending_death);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_asteroids_pending_death);
  __pyx_cur_scope->__pyx_v_current_timestep = __pyx_v_current_timestep;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_current_timestep);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_current_timestep);
  __pyx_cur_scope->__pyx_v_game_state = __pyx_v_game_state;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_game_state);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_game_state);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_verify_asteroid_does_not_appear_in_wrong_timestep);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3470, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_mstate_global->__pyx_kp_u_dict_int_list_Asteroid) < 0) __PYX_ERR(0, 3470, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3470, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3470, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3470, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3470, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_141check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot, 0, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[143])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3470, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2, __pyx_t_4) < 0) __PYX_ERR(0, 3470, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot {
  PyObject_HEAD
  PyObject *__pyx_v_asteroids_pending_death;
  PyObject *__pyx_v_current_timestep;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state;
};

 3471:     # global asteroid_new_track_total_time

 3472:     #start_time = time.perf_counter()

 3473:     # This assumes all asteroids are wrapped/within the game bounds!

 3474:     # print(f"Checking pending shots for timestep {current_timestep}")

+3475:     def verify_asteroid_does_not_appear_in_wrong_timestep(a: Asteroid) -> bool:  # REMOVE_FOR_COMPETITION

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_1verify_asteroid_does_not_appear_in_wrong_timestep(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_1verify_asteroid_does_not_appear_in_wrong_timestep = {"verify_asteroid_does_not_appear_in_wrong_timestep", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_1verify_asteroid_does_not_appear_in_wrong_timestep, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_1verify_asteroid_does_not_appear_in_wrong_timestep(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("verify_asteroid_does_not_appear_in_wrong_timestep (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_a,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3475, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3475, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "verify_asteroid_does_not_appear_in_wrong_timestep", 0) < 0) __PYX_ERR(0, 3475, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("verify_asteroid_does_not_appear_in_wrong_timestep", 1, 1, 1, i); __PYX_ERR(0, 3475, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3475, __pyx_L3_error)
    }
    __pyx_v_a = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("verify_asteroid_does_not_appear_in_wrong_timestep", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3475, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot.verify_asteroid_does_not_appear_in_wrong_timestep", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "a", 0))) __PYX_ERR(0, 3475, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_verify_asteroid_does_not_appear_in_wrong_timestep(__pyx_self, __pyx_v_a);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_verify_asteroid_does_not_appear_in_wrong_timestep(PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_a) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot *__pyx_outer_scope;
  PyObject *__pyx_v_timestep = NULL;
  PyObject *__pyx_v_asts_list = NULL;
  double __pyx_v_delta;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_11_check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_AddTraceback("neo_controller.check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot.verify_asteroid_does_not_appear_in_wrong_timestep", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_timestep);
  __Pyx_XDECREF(__pyx_v_asts_list);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3475, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_a, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3475, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3475, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_1verify_asteroid_does_not_appear_in_wrong_timestep, 0, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3475, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_verify_asteroid_does_not_appear_in_wrong_timestep = __pyx_t_2;
  __pyx_t_2 = 0;

 3476:         # print(f"Verifying asteroid {ast_to_string(a)}")  # REMOVE_FOR_COMPETITION

+3477:         for timestep, asts_list in asteroids_pending_death.items():  # REMOVE_FOR_COMPETITION

  __pyx_t_2 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_asteroids_pending_death)) { __Pyx_RaiseClosureNameError("asteroids_pending_death"); __PYX_ERR(0, 3477, __pyx_L1_error) }
  if (unlikely(__pyx_cur_scope->__pyx_v_asteroids_pending_death == Py_None)) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items");
    __PYX_ERR(0, 3477, __pyx_L1_error)
  }
  __pyx_t_5 = __Pyx_dict_iterator(__pyx_cur_scope->__pyx_v_asteroids_pending_death, 1, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3477, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_1);
  __pyx_t_1 = __pyx_t_5;
  __pyx_t_5 = 0;
  while (1) {
    __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4);
    if (unlikely(__pyx_t_7 == 0)) break;
    if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 3477, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_XDECREF_SET(__pyx_v_timestep, __pyx_t_5);
    __pyx_t_5 = 0;
    __Pyx_XDECREF_SET(__pyx_v_asts_list, __pyx_t_6);
    __pyx_t_6 = 0;

+3478:             if is_asteroid_in_list(asts_list, a, game_state):  # REMOVE_FOR_COMPETITION

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_is_asteroid_in_list); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (unlikely(!__pyx_cur_scope->__pyx_v_game_state)) { __Pyx_RaiseClosureNameError("game_state"); __PYX_ERR(0, 3478, __pyx_L1_error) }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_v_asts_list, ((PyObject *)__pyx_v_a), ((PyObject *)__pyx_cur_scope->__pyx_v_game_state)};
      __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 3478, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_10) {
/* … */
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3479:                 delta = float(timestep - current_timestep)  # REMOVE_FOR_COMPETITION

      if (unlikely(!__pyx_cur_scope->__pyx_v_current_timestep)) { __Pyx_RaiseClosureNameError("current_timestep"); __PYX_ERR(0, 3479, __pyx_L1_error) }
      __pyx_t_6 = PyNumber_Subtract(__pyx_v_timestep, __pyx_cur_scope->__pyx_v_current_timestep); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3479, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_11 = __Pyx_PyObject_AsDouble(__pyx_t_6); if (unlikely(__pyx_t_11 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3479, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_v_delta = __pyx_t_11;

 3480:                 # Check for periodic asteroid movement so we don't raise unnecessary false alarms  # REMOVE_FOR_COMPETITION

+3481:                 if abs(delta) <= 120 and not ((is_close_to_zero(float(abs(delta))*DELTA_TIME*a.velocity[0] % game_state.map_size[0]) and is_close_to_zero(float(abs(delta))*DELTA_TIME*a.velocity[1] % game_state.map_size[1])) or is_close(float(abs(delta))*DELTA_TIME*a.velocity[0] % game_state.map_size[0], game_state.map_size[0]) or is_close(float(abs(delta))*DELTA_TIME*a.velocity[1] % game_state.map_size[1], game_state.map_size[1])):  # REMOVE_FOR_COMPETITION

      __pyx_t_11 = fabs(__pyx_v_delta); 
      __pyx_t_12 = (__pyx_t_11 <= 120.0);
      if (__pyx_t_12) {
      } else {
        __pyx_t_10 = __pyx_t_12;
        goto __pyx_L7_bool_binop_done;
      }
      __pyx_t_8 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_11 = fabs(__pyx_v_delta); 
      __pyx_t_13 = PyFloat_FromDouble(__pyx_t_11); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_15 = PyNumber_Multiply(__pyx_t_13, __pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_14, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_14 = PyNumber_Multiply(__pyx_t_15, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_cur_scope->__pyx_v_game_state)) { __Pyx_RaiseClosureNameError("game_state"); __PYX_ERR(0, 3481, __pyx_L1_error) }
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = PyNumber_Remainder(__pyx_t_14, __pyx_t_15); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_8);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_13};
        __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3481, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
      }
      __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_16 < 0))) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (!__pyx_t_16) {
        goto __pyx_L10_next_or;
      } else {
      }
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_11 = fabs(__pyx_v_delta); 
      __pyx_t_8 = PyFloat_FromDouble(__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_14 = PyNumber_Multiply(__pyx_t_8, __pyx_t_15); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_15, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_15 = PyNumber_Multiply(__pyx_t_14, __pyx_t_8); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_cur_scope->__pyx_v_game_state)) { __Pyx_RaiseClosureNameError("game_state"); __PYX_ERR(0, 3481, __pyx_L1_error) }
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_14 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = PyNumber_Remainder(__pyx_t_15, __pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_13))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_13);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8};
        __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3481, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
      }
      __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_16 < 0))) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (!__pyx_t_16) {
      } else {
        __pyx_t_12 = __pyx_t_16;
        goto __pyx_L9_bool_binop_done;
      }
      __pyx_L10_next_or:;
      __pyx_t_13 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_11 = fabs(__pyx_v_delta); 
      __pyx_t_5 = PyFloat_FromDouble(__pyx_t_11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_15 = PyNumber_Multiply(__pyx_t_5, __pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_14, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_14 = PyNumber_Multiply(__pyx_t_15, __pyx_t_5); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_cur_scope->__pyx_v_game_state)) { __Pyx_RaiseClosureNameError("game_state"); __PYX_ERR(0, 3481, __pyx_L1_error) }
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = PyNumber_Remainder(__pyx_t_14, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      if (unlikely(!__pyx_cur_scope->__pyx_v_game_state)) { __Pyx_RaiseClosureNameError("game_state"); __PYX_ERR(0, 3481, __pyx_L1_error) }
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_14 = __Pyx_GetItemInt(__pyx_t_15, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_8))) {
        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_8);
        assert(__pyx_t_13);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
        __Pyx_INCREF(__pyx_t_13);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_13, __pyx_t_5, __pyx_t_14};
        __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3481, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
      }
      __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_16 < 0))) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (!__pyx_t_16) {
      } else {
        __pyx_t_12 = __pyx_t_16;
        goto __pyx_L9_bool_binop_done;
      }
      __pyx_t_8 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_11 = fabs(__pyx_v_delta); 
      __pyx_t_5 = PyFloat_FromDouble(__pyx_t_11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_15 = PyNumber_Multiply(__pyx_t_5, __pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_13, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_13 = PyNumber_Multiply(__pyx_t_15, __pyx_t_5); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_cur_scope->__pyx_v_game_state)) { __Pyx_RaiseClosureNameError("game_state"); __PYX_ERR(0, 3481, __pyx_L1_error) }
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = PyNumber_Remainder(__pyx_t_13, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      if (unlikely(!__pyx_cur_scope->__pyx_v_game_state)) { __Pyx_RaiseClosureNameError("game_state"); __PYX_ERR(0, 3481, __pyx_L1_error) }
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_15, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_14))) {
        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_14);
        assert(__pyx_t_8);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_14, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_5, __pyx_t_13};
        __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3481, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
      }
      __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_16 < 0))) __PYX_ERR(0, 3481, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_12 = __pyx_t_16;
      __pyx_L9_bool_binop_done:;
      __pyx_t_16 = (!__pyx_t_12);
      __pyx_t_10 = __pyx_t_16;
      __pyx_L7_bool_binop_done:;
      if (unlikely(__pyx_t_10)) {
/* … */
      }

+3482:                     raise Exception(f"Asteroid {a} from actual ts {current_timestep} appears in list on ts {timestep} with a delta of {delta}!")  # REMOVE_FOR_COMPETITION

        __pyx_t_14 = NULL;
        __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
        __pyx_t_13 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
        __pyx_t_5 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3482, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (unlikely(!__pyx_cur_scope->__pyx_v_current_timestep)) { __Pyx_RaiseClosureNameError("current_timestep"); __PYX_ERR(0, 3482, __pyx_L1_error) }
        __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_cur_scope->__pyx_v_current_timestep, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3482, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_timestep, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3482, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_17 = PyFloat_FromDouble(__pyx_v_delta); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 3482, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_t_17, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3482, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Asteroid;
        __pyx_t_19[1] = __pyx_t_5;
        __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u_from_actual_ts;
        __pyx_t_19[3] = __pyx_t_8;
        __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u_appears_in_list_on_ts;
        __pyx_t_19[5] = __pyx_t_15;
        __pyx_t_19[6] = __pyx_mstate_global->__pyx_kp_u_with_a_delta_of;
        __pyx_t_19[7] = __pyx_t_18;
        __pyx_t_19[8] = __pyx_mstate_global->__pyx_kp_u__16;
        __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_19, 9, 9 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 16 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 23 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 17 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_18));
        if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 3482, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __pyx_t_9 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_t_17};
          __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3482, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
        }
        __Pyx_Raise(__pyx_t_6, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __PYX_ERR(0, 3482, __pyx_L1_error)

+3483:                 return False  # REMOVE_FOR_COMPETITION

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;

+3484:         return True  # REMOVE_FOR_COMPETITION

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_True);
  __pyx_r = Py_True;
  goto __pyx_L0;

 3485: 

 3486:     # Check whether the asteroid has already been shot at, or if we can shoot at it again

 3487:     #asteroid = asteroid.copy()

 3488:     #asteroid.position = (asteroid.position[0] % game_state.map_size[0], asteroid.position[1] % game_state.map_size[1])

+3489:     if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3489, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3489, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_3) {
/* … */
  }

+3490:         assert check_coordinate_bounds(game_state, asteroid.position[0], asteroid.position[1]) or current_timestep == 0, f"Asteroid out of bounds! {asteroid.position}"  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_8 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_8 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_1, ((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_t_6, __pyx_t_7};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3490, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 3490, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (!__pyx_t_9) {
      } else {
        __pyx_t_3 = __pyx_t_9;
        goto __pyx_L4_bool_binop_done;
      }
      __pyx_t_9 = (__Pyx_PyLong_BoolEqObjC(__pyx_cur_scope->__pyx_v_current_timestep, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 3490, __pyx_L1_error)
      __pyx_t_3 = __pyx_t_9;
      __pyx_L4_bool_binop_done:;
      if (unlikely(!__pyx_t_3)) {
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3490, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3490, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Asteroid_out_of_bounds, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3490, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __PYX_ERR(0, 3490, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 3490, __pyx_L1_error)
    #endif

+3491:         if not check_coordinate_bounds(game_state, asteroid.position[0], asteroid.position[1]):  # REMOVE_FOR_COMPETITION

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_6, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_8 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_7))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
      __pyx_t_8 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_4, ((PyObject *)__pyx_cur_scope->__pyx_v_game_state), __pyx_t_1, __pyx_t_5};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3491, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3491, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_9 = (!__pyx_t_3);
    if (__pyx_t_9) {
/* … */
    }

+3492:             print("WARNING, the scenario started with the asteroids out of bounds!")  # REMOVE_FOR_COMPETITION

      __pyx_t_7 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_5 = __pyx_builtin_print; 
      __pyx_t_8 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_WARNING_the_scenario_started_wit};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3492, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3493:     if current_timestep in asteroids_pending_death:

  __pyx_t_9 = (__Pyx_PyDict_ContainsTF(__pyx_cur_scope->__pyx_v_current_timestep, __pyx_cur_scope->__pyx_v_asteroids_pending_death, Py_EQ)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 3493, __pyx_L1_error)
  if (__pyx_t_9) {
/* … */
  }

+3494:         if VERIFY_AST_TRACKING:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_VERIFY_AST_TRACKING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3494, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 3494, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_9) {
/* … */
    }

+3495:             if not is_asteroid_in_list(asteroids_pending_death[current_timestep], asteroid, game_state):  # REMOVE_FOR_COMPETITION

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_is_asteroid_in_list); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3495, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_asteroids_pending_death, __pyx_cur_scope->__pyx_v_current_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3495, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_8 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_8 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_t_1, ((PyObject *)__pyx_v_asteroid), ((PyObject *)__pyx_cur_scope->__pyx_v_game_state)};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3495, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 3495, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_3 = (!__pyx_t_9);
      if (__pyx_t_3) {
/* … */
      }

+3496:                 return verify_asteroid_does_not_appear_in_wrong_timestep(asteroid)  # REMOVE_FOR_COMPETITION

        __Pyx_XDECREF(__pyx_r);
        __pyx_t_2 = __pyx_pf_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_verify_asteroid_does_not_appear_in_wrong_timestep(__pyx_v_verify_asteroid_does_not_appear_in_wrong_timestep, __pyx_v_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3496, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        goto __pyx_L0;

 3497:         # return_value = not is_asteroid_in_list(asteroids_pending_death[current_timestep], asteroid, game_state)

 3498:         #asteroid_new_track_total_time += time.perf_counter() - start_time

+3499:         return not is_asteroid_in_list(asteroids_pending_death[current_timestep], asteroid, game_state)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_7 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_is_asteroid_in_list); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3499, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_asteroids_pending_death, __pyx_cur_scope->__pyx_v_current_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3499, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
      assert(__pyx_t_7);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
      __pyx_t_8 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_t_5, ((PyObject *)__pyx_v_asteroid), ((PyObject *)__pyx_cur_scope->__pyx_v_game_state)};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3499, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3499, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyBool_FromLong((!__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3499, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

 3500:     else:

+3501:         if VERIFY_AST_TRACKING:  # REMOVE_FOR_COMPETITION

  /*else*/ {
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_VERIFY_AST_TRACKING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3501, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3501, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_3) {
/* … */
    }

 3502:             # print(asteroids_pending_death)  # REMOVE_FOR_COMPETITION

+3503:             return verify_asteroid_does_not_appear_in_wrong_timestep(asteroid)  # REMOVE_FOR_COMPETITION

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_2 = __pyx_pf_14neo_controller_76check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot_verify_asteroid_does_not_appear_in_wrong_timestep(__pyx_v_verify_asteroid_does_not_appear_in_wrong_timestep, __pyx_v_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3503, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;

 3504:         #asteroid_new_track_total_time += time.perf_counter() - start_time

+3505:         return True

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;
  }

 3506: 

 3507: 

+3508: def time_travel_asteroid(asteroid: Asteroid, timesteps: int, game_state: GameState) -> Asteroid:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_Asteroid *__pyx_pw_14neo_controller_143time_travel_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_142time_travel_asteroid, "Project an asteroid into the future or past. This automatically wraps the asteroid's position");
static PyMethodDef __pyx_mdef_14neo_controller_143time_travel_asteroid = {"time_travel_asteroid", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_143time_travel_asteroid, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_142time_travel_asteroid};
static struct __pyx_obj_14neo_controller_Asteroid *__pyx_pw_14neo_controller_143time_travel_asteroid(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  PyObject *__pyx_v_timesteps = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("time_travel_asteroid (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_timesteps,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3508, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3508, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3508, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3508, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "time_travel_asteroid", 0) < 0) __PYX_ERR(0, 3508, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("time_travel_asteroid", 1, 3, 3, i); __PYX_ERR(0, 3508, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3508, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3508, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3508, __pyx_L3_error)
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_timesteps = ((PyObject*)values[1]);
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("time_travel_asteroid", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3508, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.time_travel_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 3508, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timesteps), (&PyLong_Type), 0, "timesteps", 2))) __PYX_ERR(0, 3508, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3508, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_142time_travel_asteroid(__pyx_self, __pyx_v_asteroid, __pyx_v_timesteps, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_Asteroid *__pyx_pf_14neo_controller_142time_travel_asteroid(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, PyObject *__pyx_v_timesteps, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("neo_controller.time_travel_asteroid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3508, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3508, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_143time_travel_asteroid, 0, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[144])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3508, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid, __pyx_t_2) < 0) __PYX_ERR(0, 3508, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3509:     '''Project an asteroid into the future or past. This automatically wraps the asteroid's position'''

 3510:     # The ts=0 shortcut isn't good because it doesn't wrap the asteroid!

 3511:     #if timesteps == 0:

 3512:         #print("WARNING: Time travelling asteroid by 0 timesteps! If this is rare, it's no cause for concern")

 3513:         #return asteroid.copy()

+3514:     return Asteroid(

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 

+3515:         position=((asteroid.position[0] + float(timesteps)*asteroid.velocity[0]*DELTA_TIME) % game_state.map_size[0], (asteroid.position[1] + float(timesteps)*asteroid.velocity[1]*DELTA_TIME) % game_state.map_size[1]),

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = PyLong_AsDouble(__pyx_v_timesteps); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3515, __pyx_L1_error)
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyNumber_Multiply(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Remainder(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = PyLong_AsDouble(__pyx_v_timesteps); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3515, __pyx_L1_error)
  __pyx_t_5 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = PyNumber_Add(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyNumber_Remainder(__pyx_t_9, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 3515, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 3515, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;

+3516:         velocity=asteroid.velocity,

  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+3517:         size=asteroid.size,

  __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_asteroid->size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3517, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+3518:         mass=asteroid.mass,

  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3518, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);

+3519:         radius=asteroid.radius,

  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_asteroid->radius); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3519, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);

+3520:         timesteps_until_appearance=asteroid.timesteps_until_appearance

  __pyx_t_10 = __Pyx_PyLong_From_int(__pyx_v_asteroid->timesteps_until_appearance); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3520, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_11 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_12 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3514, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_8, __pyx_t_12, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3514, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_5, __pyx_t_12, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 3514, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_4, __pyx_t_12, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 3514, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_9, __pyx_t_12, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 3514, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_t_7, __pyx_t_12, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 3514, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_t_10, __pyx_t_12, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 3514, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_12);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3514, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3521:     )

 3522: 

 3523: 

+3524: def time_travel_asteroid_s(asteroid: Asteroid, time: float, game_state: GameState) -> Asteroid:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_Asteroid *__pyx_pw_14neo_controller_145time_travel_asteroid_s(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_144time_travel_asteroid_s, "Project an asteroid into the future or past. This automatically wraps the asteroid's position");
static PyMethodDef __pyx_mdef_14neo_controller_145time_travel_asteroid_s = {"time_travel_asteroid_s", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_145time_travel_asteroid_s, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_144time_travel_asteroid_s};
static struct __pyx_obj_14neo_controller_Asteroid *__pyx_pw_14neo_controller_145time_travel_asteroid_s(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid = 0;
  double __pyx_v_time;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("time_travel_asteroid_s (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroid,&__pyx_mstate_global->__pyx_n_u_time,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3524, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3524, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3524, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3524, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "time_travel_asteroid_s", 0) < 0) __PYX_ERR(0, 3524, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("time_travel_asteroid_s", 1, 3, 3, i); __PYX_ERR(0, 3524, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3524, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3524, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3524, __pyx_L3_error)
    }
    __pyx_v_asteroid = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_time = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3524, __pyx_L3_error)
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("time_travel_asteroid_s", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3524, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.time_travel_asteroid_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "asteroid", 0))) __PYX_ERR(0, 3524, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3524, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_144time_travel_asteroid_s(__pyx_self, __pyx_v_asteroid, __pyx_v_time, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_Asteroid *__pyx_pf_14neo_controller_144time_travel_asteroid_s(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_asteroid, double __pyx_v_time, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.time_travel_asteroid_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3524, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3524, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3524, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3524, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 3524, __pyx_L1_error)
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_145time_travel_asteroid_s, 0, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid_s, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[145])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3524, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid_s, __pyx_t_4) < 0) __PYX_ERR(0, 3524, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 3525:     '''Project an asteroid into the future or past. This automatically wraps the asteroid's position'''

 3526:     # The ts=0 shortcut isn't good because it doesn't wrap the asteroid!

 3527:     #if timesteps == 0:

 3528:         #print("WARNING: Time travelling asteroid by 0 timesteps! If this is rare, it's no cause for concern")

 3529:         #return asteroid.copy()

+3530:     return Asteroid(

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid); 

+3531:         position=((asteroid.position[0] + time*asteroid.velocity[0]) % game_state.map_size[0], (asteroid.position[1] + time*asteroid.velocity[1]) % game_state.map_size[1]),

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_6, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyNumber_Add(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyNumber_Remainder(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_5, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyNumber_Add(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Remainder(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3531, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 3531, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 3531, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_4 = 0;

+3532:         velocity=asteroid.velocity,

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_asteroid), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3532, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+3533:         size=asteroid.size,

  __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_asteroid->size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3533, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);

+3534:         mass=asteroid.mass,

  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_asteroid->mass); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3534, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);

+3535:         radius=asteroid.radius,

  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_asteroid->radius); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3535, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+3536:         timesteps_until_appearance=asteroid.timesteps_until_appearance

  __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_asteroid->timesteps_until_appearance); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 6 : 0)] = {__pyx_t_2, NULL};
    __pyx_t_11 = __Pyx_MakeVectorcallBuilderKwds(6); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3530, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_7, __pyx_t_11, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 3530, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_4, __pyx_t_11, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 3530, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_6, __pyx_t_11, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 3530, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_8, __pyx_t_11, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 3530, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_t_5, __pyx_t_11, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 3530, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timesteps_until_appearance, __pyx_t_9, __pyx_t_11, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 3530, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_11);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3530, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_r = ((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3537:     )

 3538: 

 3539: 

+3540: class Matrix():

  __pyx_t_4 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_n_u_Matrix, __pyx_mstate_global->__pyx_n_u_Matrix, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3540, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
/* … */
  __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_mstate_global->__pyx_n_u_Matrix, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3540, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Matrix, __pyx_t_2) < 0) __PYX_ERR(0, 3540, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 3541:     # Simulates kessler_game.py and ship.py and other game mechanics

 3542:     # Has built-in controllers to do stationary targeting, maneuvers, and respawn maneuvers

 3543:     # Has fitness function to evaluate the set of moves, along with the end state

 3544:     # Can then extract the maneuver along with the future state, to execute the maneuver, and begin planning based on the future state before we actually get there

+3545:     def __init__(self, game_state: GameState, ship_state: Ship, initial_timestep: int, respawn_timer: float = 0.0, asteroids_pending_death: Optional[dict[int, list[Asteroid]]] = None, forecasted_asteroid_splits: Optional[list[Asteroid]] = None, last_timestep_fired: int = INT_NEG_INF, last_timestep_mined: int = INT_NEG_INF, mine_positions_placed: Optional[set[tuple[float, float]]] = None, halt_shooting: bool = False, fire_first_timestep: bool = False, verify_first_shot: bool = False, verify_maneuver_shots: bool = True, last_timestep_colliding: int = -1, game_state_plotter: Optional[GameStatePlotter] = None) -> None:

static PyObject *__pyx_pf_14neo_controller_159__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyTuple_New(12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_self)->arg0);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_self)->arg0);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 3, __Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_self)->arg1);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_self)->arg1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 4, __Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_self)->arg1) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 5, Py_None) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_False));
  __Pyx_GIVEREF(((PyObject*)Py_False));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 6, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_False));
  __Pyx_GIVEREF(((PyObject*)Py_False));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 7, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_False));
  __Pyx_GIVEREF(((PyObject*)Py_False));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 8, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_True));
  __Pyx_GIVEREF(((PyObject*)Py_True));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 9, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_int_neg_1));
  __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_int_neg_1));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 10, ((PyObject*)__pyx_mstate_global->__pyx_int_neg_1)) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 11, Py_None) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, Py_None) != (0)) __PYX_ERR(0, 3545, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_1__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_1__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  PyObject *__pyx_v_initial_timestep = 0;
  double __pyx_v_respawn_timer;
  PyObject *__pyx_v_asteroids_pending_death = 0;
  PyObject *__pyx_v_forecasted_asteroid_splits = 0;
  PyObject *__pyx_v_last_timestep_fired = 0;
  PyObject *__pyx_v_last_timestep_mined = 0;
  PyObject *__pyx_v_mine_positions_placed = 0;
  PyObject *__pyx_v_halt_shooting = 0;
  PyObject *__pyx_v_fire_first_timestep = 0;
  PyObject *__pyx_v_verify_first_shot = 0;
  PyObject *__pyx_v_verify_maneuver_shots = 0;
  PyObject *__pyx_v_last_timestep_colliding = 0;
  PyObject *__pyx_v_game_state_plotter = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_initial_timestep,&__pyx_mstate_global->__pyx_n_u_respawn_timer,&__pyx_mstate_global->__pyx_n_u_asteroids_pending_death,&__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits,&__pyx_mstate_global->__pyx_n_u_last_timestep_fired,&__pyx_mstate_global->__pyx_n_u_last_timestep_mined,&__pyx_mstate_global->__pyx_n_u_mine_positions_placed,&__pyx_mstate_global->__pyx_n_u_halt_shooting,&__pyx_mstate_global->__pyx_n_u_fire_first_timestep,&__pyx_mstate_global->__pyx_n_u_verify_first_shot,&__pyx_mstate_global->__pyx_n_u_verify_maneuver_shots,&__pyx_mstate_global->__pyx_n_u_last_timestep_colliding,&__pyx_mstate_global->__pyx_n_u_game_state_plotter,0};
  PyObject* values[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    struct __pyx_defaults2 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_self);
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3545, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case 16:
        values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 15:
        values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 14:
        values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 13:
        values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 12:
        values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 11:
        values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 3545, __pyx_L3_error)
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[7]) values[7] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[8]) values[8] = __Pyx_NewRef(__pyx_dynamic_args->arg1);
      if (!values[9]) values[9] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True)));
      if (!values[14]) values[14] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_neg_1)));
      if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 4, 16, i); __PYX_ERR(0, 3545, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case 16:
        values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 15:
        values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 14:
        values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 13:
        values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 12:
        values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 11:
        values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case 10:
        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3545, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3545, __pyx_L3_error)
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3545, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3545, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3545, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[7]) values[7] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[8]) values[8] = __Pyx_NewRef(__pyx_dynamic_args->arg1);
      if (!values[9]) values[9] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True)));
      if (!values[14]) values[14] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_neg_1)));
      if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[1]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[2]);
    __pyx_v_initial_timestep = ((PyObject*)values[3]);
    if (values[4]) {
      __pyx_v_respawn_timer = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_respawn_timer == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3545, __pyx_L3_error)
    } else {
      __pyx_v_respawn_timer = ((double)((double)0.0));
    }
    __pyx_v_asteroids_pending_death = ((PyObject*)values[5]);
    __pyx_v_forecasted_asteroid_splits = ((PyObject*)values[6]);
    __pyx_v_last_timestep_fired = ((PyObject*)values[7]);
    __pyx_v_last_timestep_mined = ((PyObject*)values[8]);
    __pyx_v_mine_positions_placed = ((PyObject*)values[9]);
    __pyx_v_halt_shooting = values[10];
    __pyx_v_fire_first_timestep = values[11];
    __pyx_v_verify_first_shot = values[12];
    __pyx_v_verify_maneuver_shots = values[13];
    __pyx_v_last_timestep_colliding = ((PyObject*)values[14]);
    __pyx_v_game_state_plotter = values[15];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 4, 16, __pyx_nargs); __PYX_ERR(0, 3545, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_initial_timestep), (&PyLong_Type), 0, "initial_timestep", 2))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids_pending_death), (&PyDict_Type), 1, "asteroids_pending_death", 2))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_forecasted_asteroid_splits), (&PyList_Type), 1, "forecasted_asteroid_splits", 2))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_last_timestep_fired), (&PyLong_Type), 0, "last_timestep_fired", 2))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_last_timestep_mined), (&PyLong_Type), 0, "last_timestep_mined", 2))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mine_positions_placed), (&PySet_Type), 1, "mine_positions_placed", 2))) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_last_timestep_colliding), (&PyLong_Type), 0, "last_timestep_colliding", 2))) __PYX_ERR(0, 3545, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix___init__(__pyx_self, __pyx_v_self, __pyx_v_game_state, __pyx_v_ship_state, __pyx_v_initial_timestep, __pyx_v_respawn_timer, __pyx_v_asteroids_pending_death, __pyx_v_forecasted_asteroid_splits, __pyx_v_last_timestep_fired, __pyx_v_last_timestep_mined, __pyx_v_mine_positions_placed, __pyx_v_halt_shooting, __pyx_v_fire_first_timestep, __pyx_v_verify_first_shot, __pyx_v_verify_maneuver_shots, __pyx_v_last_timestep_colliding, __pyx_v_game_state_plotter);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state, PyObject *__pyx_v_initial_timestep, double __pyx_v_respawn_timer, PyObject *__pyx_v_asteroids_pending_death, PyObject *__pyx_v_forecasted_asteroid_splits, PyObject *__pyx_v_last_timestep_fired, PyObject *__pyx_v_last_timestep_mined, PyObject *__pyx_v_mine_positions_placed, PyObject *__pyx_v_halt_shooting, PyObject *__pyx_v_fire_first_timestep, PyObject *__pyx_v_verify_first_shot, PyObject *__pyx_v_verify_maneuver_shots, PyObject *__pyx_v_last_timestep_colliding, PyObject *__pyx_v_game_state_plotter) {
  PyObject *__pyx_v_bias = NULL;
  PyObject *__pyx_9genexpr21__pyx_v_a = NULL;
  PyObject *__pyx_9genexpr22__pyx_v_s = NULL;
  PyObject *__pyx_9genexpr23__pyx_v_b = NULL;
  PyObject *__pyx_9genexpr24__pyx_v_m = NULL;
  PyObject *__pyx_9genexpr25__pyx_v_timestep = NULL;
  PyObject *__pyx_9genexpr25__pyx_v_l = NULL;
  PyObject *__pyx_9genexpr26__pyx_v_a = NULL;
  CYTHON_UNUSED PyObject *__pyx_9genexpr27__pyx_v__ = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_INCREF(__pyx_v_asteroids_pending_death);
  __Pyx_INCREF(__pyx_v_forecasted_asteroid_splits);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("neo_controller.Matrix.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_bias);
  __Pyx_XDECREF(__pyx_9genexpr21__pyx_v_a);
  __Pyx_XDECREF(__pyx_9genexpr22__pyx_v_s);
  __Pyx_XDECREF(__pyx_9genexpr23__pyx_v_b);
  __Pyx_XDECREF(__pyx_9genexpr24__pyx_v_m);
  __Pyx_XDECREF(__pyx_9genexpr25__pyx_v_timestep);
  __Pyx_XDECREF(__pyx_9genexpr25__pyx_v_l);
  __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_a);
  __Pyx_XDECREF(__pyx_9genexpr27__pyx_v__);
  __Pyx_XDECREF(__pyx_v_asteroids_pending_death);
  __Pyx_XDECREF(__pyx_v_forecasted_asteroid_splits);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_mstate_global->__pyx_kp_u_Optional_dict_int_list_Asteroid) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_mstate_global->__pyx_kp_u_Optional_list_Asteroid) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_mstate_global->__pyx_kp_u_Optional_set_tuple_float_float) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_halt_shooting, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_verify_first_shot, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_mstate_global->__pyx_kp_u_Optional_GameStatePlotter) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_1__init__, 0, __pyx_mstate_global->__pyx_n_u_Matrix___init, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[146])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_defaults2)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (!(likely(PyLong_CheckExact(__pyx_t_9))||((__pyx_t_9) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_9))) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_t_3)->arg0 = ((PyObject*)__pyx_t_9);
  __Pyx_GIVEREF(__pyx_t_9);
  __pyx_t_9 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (!(likely(PyLong_CheckExact(__pyx_t_9))||((__pyx_t_9) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_9))) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_CyFunction_Defaults(struct __pyx_defaults2, __pyx_t_3)->arg1 = ((PyObject*)__pyx_t_9);
  __Pyx_GIVEREF(__pyx_t_9);
  __pyx_t_9 = 0;
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_3, __pyx_pf_14neo_controller_159__defaults__);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_3) < 0) __PYX_ERR(0, 3545, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
struct __pyx_defaults2 {
  PyObject_HEAD
  PyObject *arg0;
  PyObject *arg1;
};

 3546:         #if not is_close_to_zero(ship_state.speed):

 3547:         #    print(f"WARNING: The ship speed when starting the sim is not zero! It's {ship_state.speed=}, {ship_state.velocity=}")

+3548:         if asteroids_pending_death is None:

  __pyx_t_1 = (__pyx_v_asteroids_pending_death == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+3549:             asteroids_pending_death = {}  # Keys are timesteps, and the values are the asteroids that still have midair bullets travelling toward them, so we don't want to shoot at them again

    __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3549, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_asteroids_pending_death, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+3550:         if forecasted_asteroid_splits is None:

  __pyx_t_1 = (__pyx_v_forecasted_asteroid_splits == ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
  }

+3551:             forecasted_asteroid_splits = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3551, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_forecasted_asteroid_splits, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+3552:         self.initial_timestep = initial_timestep

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_v_initial_timestep) < 0) __PYX_ERR(0, 3552, __pyx_L1_error)

+3553:         self.future_timesteps: int = 0

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps, __pyx_mstate_global->__pyx_int_0) < 0) __PYX_ERR(0, 3553, __pyx_L1_error)

+3554:         self.last_timestep_fired = last_timestep_fired

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_v_last_timestep_fired) < 0) __PYX_ERR(0, 3554, __pyx_L1_error)

+3555:         self.last_timestep_mined = last_timestep_mined

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_v_last_timestep_mined) < 0) __PYX_ERR(0, 3555, __pyx_L1_error)

+3556:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3556, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3556, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_1) {
/* … */
  }

+3557:             assert (ship_state.is_respawning == bool(respawn_timer))  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_ship_state->is_respawning); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3557, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_respawn_timer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3557, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3557, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3557, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3557, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3557, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 3557, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 3557, __pyx_L1_error)
    #endif

+3558:         self.game_state: GameState = game_state.copy()

  __pyx_t_3 = ((PyObject *)__pyx_v_game_state);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3558, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_t_4) < 0) __PYX_ERR(0, 3558, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3559:         self.ship_state: Ship = ship_state.copy()

  __pyx_t_3 = ((PyObject *)__pyx_v_ship_state);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3559, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_4) < 0) __PYX_ERR(0, 3559, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3560:         self.game_state.asteroids = [a.copy() for a in game_state.asteroids]

  { /* enter inner scope */
    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3560, __pyx_L8_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(__pyx_v_game_state->asteroids == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 3560, __pyx_L8_error)
    }
    __pyx_t_3 = __pyx_v_game_state->asteroids; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3560, __pyx_L8_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3560, __pyx_L8_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_9genexpr21__pyx_v_a, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_7 = __pyx_9genexpr21__pyx_v_a;
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3560, __pyx_L8_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 3560, __pyx_L8_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_9genexpr21__pyx_v_a); __pyx_9genexpr21__pyx_v_a = 0;
    goto __pyx_L12_exit_scope;
    __pyx_L8_error:;
    __Pyx_XDECREF(__pyx_9genexpr21__pyx_v_a); __pyx_9genexpr21__pyx_v_a = 0;
    goto __pyx_L1_error;
    __pyx_L12_exit_scope:;
  } /* exit inner scope */
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3560, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__Pyx_PyObject_SetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_4) < 0) __PYX_ERR(0, 3560, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3561:         self.game_state.ships = [s.copy() for s in game_state.ships]

  { /* enter inner scope */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3561, __pyx_L15_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (unlikely(__pyx_v_game_state->ships == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 3561, __pyx_L15_error)
    }
    __pyx_t_4 = __pyx_v_game_state->ships; __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3561, __pyx_L15_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3561, __pyx_L15_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_9genexpr22__pyx_v_s, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_7 = __pyx_9genexpr22__pyx_v_s;
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3561, __pyx_L15_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 3561, __pyx_L15_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_9genexpr22__pyx_v_s); __pyx_9genexpr22__pyx_v_s = 0;
    goto __pyx_L19_exit_scope;
    __pyx_L15_error:;
    __Pyx_XDECREF(__pyx_9genexpr22__pyx_v_s); __pyx_9genexpr22__pyx_v_s = 0;
    goto __pyx_L1_error;
    __pyx_L19_exit_scope:;
  } /* exit inner scope */
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3561, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ships, __pyx_t_3) < 0) __PYX_ERR(0, 3561, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3562:         self.game_state.bullets = [b.copy() for b in game_state.bullets]

  { /* enter inner scope */
    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3562, __pyx_L22_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(__pyx_v_game_state->bullets == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 3562, __pyx_L22_error)
    }
    __pyx_t_3 = __pyx_v_game_state->bullets; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3562, __pyx_L22_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3562, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_9genexpr23__pyx_v_b, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_7 = __pyx_9genexpr23__pyx_v_b;
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3562, __pyx_L22_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 3562, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_9genexpr23__pyx_v_b); __pyx_9genexpr23__pyx_v_b = 0;
    goto __pyx_L26_exit_scope;
    __pyx_L22_error:;
    __Pyx_XDECREF(__pyx_9genexpr23__pyx_v_b); __pyx_9genexpr23__pyx_v_b = 0;
    goto __pyx_L1_error;
    __pyx_L26_exit_scope:;
  } /* exit inner scope */
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3562, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__Pyx_PyObject_SetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_4) < 0) __PYX_ERR(0, 3562, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3563:         self.game_state.mines = [m.copy() for m in game_state.mines]

  { /* enter inner scope */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3563, __pyx_L29_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (unlikely(__pyx_v_game_state->mines == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 3563, __pyx_L29_error)
    }
    __pyx_t_4 = __pyx_v_game_state->mines; __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3563, __pyx_L29_error)
        #endif
        if (__pyx_t_6 >= __pyx_temp) break;
      }
      __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_6);
      ++__pyx_t_6;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3563, __pyx_L29_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_9genexpr24__pyx_v_m, __pyx_t_2);
      __pyx_t_2 = 0;
      __pyx_t_7 = __pyx_9genexpr24__pyx_v_m;
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3563, __pyx_L29_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 3563, __pyx_L29_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_9genexpr24__pyx_v_m); __pyx_9genexpr24__pyx_v_m = 0;
    goto __pyx_L33_exit_scope;
    __pyx_L29_error:;
    __Pyx_XDECREF(__pyx_9genexpr24__pyx_v_m); __pyx_9genexpr24__pyx_v_m = 0;
    goto __pyx_L1_error;
    __pyx_L33_exit_scope:;
  } /* exit inner scope */
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3563, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_mines, __pyx_t_3) < 0) __PYX_ERR(0, 3563, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3564:         self.other_ships = get_other_ships(self.game_state, ship_state.id)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_other_ships); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3564, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3564, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_ship_state->id); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3564, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_7, __pyx_t_8};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships, __pyx_t_4) < 0) __PYX_ERR(0, 3564, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3565:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3565, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_1) {
/* … */
  }

+3566:             assert 0 <= len(self.other_ships) <= 1  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3566, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3566, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_1 = (0 <= __pyx_t_6);
      if (__pyx_t_1) {
        __pyx_t_1 = (__pyx_t_6 <= 1);
      }
      if (unlikely(!__pyx_t_1)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 3566, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 3566, __pyx_L1_error)
    #endif

+3567:         self.ship_move_sequence: list[Action] = []

  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3567, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence, __pyx_t_4) < 0) __PYX_ERR(0, 3567, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3568:         self.state_sequence: list[SimState] = []

  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3568, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence, __pyx_t_4) < 0) __PYX_ERR(0, 3568, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3569:         self.asteroids_shot: int = 0

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_mstate_global->__pyx_int_0) < 0) __PYX_ERR(0, 3569, __pyx_L1_error)

+3570:         self.asteroids_pending_death: dict[int, list[Asteroid]] = {timestep: list(l) for timestep, l in asteroids_pending_death.items()}

  { /* enter inner scope */
    __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3570, __pyx_L37_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = 0;
    if (unlikely(__pyx_v_asteroids_pending_death == Py_None)) {
      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items");
      __PYX_ERR(0, 3570, __pyx_L37_error)
    }
    __pyx_t_8 = __Pyx_dict_iterator(__pyx_v_asteroids_pending_death, 1, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3570, __pyx_L37_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_XDECREF(__pyx_t_2);
    __pyx_t_2 = __pyx_t_8;
    __pyx_t_8 = 0;
    while (1) {
      __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_9, &__pyx_t_6, &__pyx_t_8, &__pyx_t_7, NULL, __pyx_t_10);
      if (unlikely(__pyx_t_11 == 0)) break;
      if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3570, __pyx_L37_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_XDECREF_SET(__pyx_9genexpr25__pyx_v_timestep, __pyx_t_8);
      __pyx_t_8 = 0;
      __Pyx_XDECREF_SET(__pyx_9genexpr25__pyx_v_l, __pyx_t_7);
      __pyx_t_7 = 0;
      __pyx_t_7 = PySequence_List(__pyx_9genexpr25__pyx_v_l); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3570, __pyx_L37_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(PyDict_SetItem(__pyx_t_4, (PyObject*)__pyx_9genexpr25__pyx_v_timestep, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 3570, __pyx_L37_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_9genexpr25__pyx_v_l); __pyx_9genexpr25__pyx_v_l = 0;
    __Pyx_XDECREF(__pyx_9genexpr25__pyx_v_timestep); __pyx_9genexpr25__pyx_v_timestep = 0;
    goto __pyx_L40_exit_scope;
    __pyx_L37_error:;
    __Pyx_XDECREF(__pyx_9genexpr25__pyx_v_l); __pyx_9genexpr25__pyx_v_l = 0;
    __Pyx_XDECREF(__pyx_9genexpr25__pyx_v_timestep); __pyx_9genexpr25__pyx_v_timestep = 0;
    goto __pyx_L1_error;
    __pyx_L40_exit_scope:;
  } /* exit inner scope */
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_4) < 0) __PYX_ERR(0, 3570, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3571:         self.forecasted_asteroid_splits: list[Asteroid] = [a.copy() for a in forecasted_asteroid_splits]

  { /* enter inner scope */
    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3571, __pyx_L43_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(__pyx_v_forecasted_asteroid_splits == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(0, 3571, __pyx_L43_error)
    }
    __pyx_t_2 = __pyx_v_forecasted_asteroid_splits; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_9 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3571, __pyx_L43_error)
        #endif
        if (__pyx_t_9 >= __pyx_temp) break;
      }
      __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_9);
      ++__pyx_t_9;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3571, __pyx_L43_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_XDECREF_SET(__pyx_9genexpr26__pyx_v_a, __pyx_t_7);
      __pyx_t_7 = 0;
      __pyx_t_8 = __pyx_9genexpr26__pyx_v_a;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
        __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3571, __pyx_L43_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 3571, __pyx_L43_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_a); __pyx_9genexpr26__pyx_v_a = 0;
    goto __pyx_L47_exit_scope;
    __pyx_L43_error:;
    __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_a); __pyx_9genexpr26__pyx_v_a = 0;
    goto __pyx_L1_error;
    __pyx_L47_exit_scope:;
  } /* exit inner scope */
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_4) < 0) __PYX_ERR(0, 3571, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3572:         self.halt_shooting: bool = halt_shooting # This probably means we're doing a respawn maneuver

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting, __pyx_v_halt_shooting) < 0) __PYX_ERR(0, 3572, __pyx_L1_error)

+3573:         self.fire_next_timestep_flag: bool = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 3573, __pyx_L1_error)

+3574:         self.fire_first_timestep: bool = fire_first_timestep

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_v_fire_first_timestep) < 0) __PYX_ERR(0, 3574, __pyx_L1_error)

+3575:         self.game_state_plotter: Optional[GameStatePlotter] = game_state_plotter

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_v_game_state_plotter) < 0) __PYX_ERR(0, 3575, __pyx_L1_error)

+3576:         self.sim_id = random.randint(1, 100000)

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_randint); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[19], NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sim_id, __pyx_t_4) < 0) __PYX_ERR(0, 3576, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[19] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_100000); if (unlikely(!__pyx_mstate_global->__pyx_tuple[19])) __PYX_ERR(0, 3576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[19]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[19]);

 3577:         #if self.sim_id in [15869, 73186]:

 3578:         #    print(f"Starting sim {self.sim_id} with ship state {ship_state}")

+3579:         self.explanation_messages: list[str] = []

  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3579, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages, __pyx_t_4) < 0) __PYX_ERR(0, 3579, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3580:         self.safety_messages: list[str] = []

  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3580, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages, __pyx_t_4) < 0) __PYX_ERR(0, 3580, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3581:         self.respawn_timer: float = respawn_timer

  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_respawn_timer); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3581, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_4) < 0) __PYX_ERR(0, 3581, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3582:         self.plot_this_sim = False #( and GAMESTATE_PLOTTING)# or (self.sim_id in [2238])

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_plot_this_sim, Py_False) < 0) __PYX_ERR(0, 3582, __pyx_L1_error)

+3583:         self.ship_crashed = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_crashed, Py_False) < 0) __PYX_ERR(0, 3583, __pyx_L1_error)

+3584:         self.backed_up_game_state_before_post_mutation: Optional[GameState] = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backed_up_game_state_before_post, Py_None) < 0) __PYX_ERR(0, 3584, __pyx_L1_error)

+3585:         self.fitness_breakdown: Optional[tuple[float, float, float, float, float, float, float, float, float]] = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fitness_breakdown, Py_None) < 0) __PYX_ERR(0, 3585, __pyx_L1_error)

+3586:         self.cancel_firing_first_timestep: bool = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cancel_firing_first_timestep, Py_False) < 0) __PYX_ERR(0, 3586, __pyx_L1_error)

+3587:         self.verify_first_shot: bool = verify_first_shot

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_verify_first_shot, __pyx_v_verify_first_shot) < 0) __PYX_ERR(0, 3587, __pyx_L1_error)

+3588:         self.intended_move_sequence: list[Action] = []

  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3588, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_intended_move_sequence, __pyx_t_4) < 0) __PYX_ERR(0, 3588, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3589:         self.sim_placed_a_mine: bool = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sim_placed_a_mine, Py_False) < 0) __PYX_ERR(0, 3589, __pyx_L1_error)

+3590:         self.verify_maneuver_shots: bool = verify_maneuver_shots

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, __pyx_v_verify_maneuver_shots) < 0) __PYX_ERR(0, 3590, __pyx_L1_error)

+3591:         self.mine_positions_placed: set[tuple[float, float]] = mine_positions_placed if mine_positions_placed is not None else set()

  __pyx_t_1 = (__pyx_v_mine_positions_placed != ((PyObject*)Py_None));
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_v_mine_positions_placed);
    __pyx_t_4 = __pyx_v_mine_positions_placed;
  } else {
    __pyx_t_2 = PySet_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3591, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __pyx_t_2;
    __pyx_t_2 = 0;
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_4) < 0) __PYX_ERR(0, 3591, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 3592:         # This is to facilitate my two-pass respawn maneuvers. The first pass doesn't shoot, and records when we will no longer hit asteroids. The second pass will begin targeting after the ship is clear from asteroids, since after shooting the respawn invincibility will be gone

+3593:         self.last_timestep_colliding: int = last_timestep_colliding if last_timestep_colliding != -1 else self.initial_timestep - 1

  __pyx_t_1 = (__Pyx_PyLong_BoolNeObjC(__pyx_v_last_timestep_colliding, __pyx_mstate_global->__pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3593, __pyx_L1_error)
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_v_last_timestep_colliding);
    __pyx_t_4 = __pyx_v_last_timestep_colliding;
  } else {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = __Pyx_PyLong_SubtractObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_4 = __pyx_t_7;
    __pyx_t_7 = 0;
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding, __pyx_t_4) < 0) __PYX_ERR(0, 3593, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 3594:         # 0 - Not a respawn maneuver, 1 - First pass of respawn maneuver, 2 - Second pass of respawn maneuver

+3595:         self.respawn_maneuver_pass_number: int = 0 if (not self.halt_shooting and last_timestep_colliding == -1) else (1 if last_timestep_colliding == -1 else 2)

  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3595, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 3595, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_13 = (!__pyx_t_12);
  if (__pyx_t_13) {
  } else {
    __pyx_t_1 = __pyx_t_13;
    goto __pyx_L48_bool_binop_done;
  }
  __pyx_t_13 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_last_timestep_colliding, __pyx_mstate_global->__pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 3595, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_13;
  __pyx_L48_bool_binop_done:;
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_t_4 = __pyx_mstate_global->__pyx_int_0;
  } else {
    __pyx_t_13 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_last_timestep_colliding, __pyx_mstate_global->__pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 3595, __pyx_L1_error)
    if (__pyx_t_13) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
      __pyx_t_7 = __pyx_mstate_global->__pyx_int_1;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2);
      __pyx_t_7 = __pyx_mstate_global->__pyx_int_2;
    }
    __pyx_t_4 = __pyx_t_7;
    __pyx_t_7 = 0;
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number, __pyx_t_4) < 0) __PYX_ERR(0, 3595, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3596:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3596, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_1) {
/* … */
  }

+3597:             if self.respawn_maneuver_pass_number == 1:  # REMOVE_FOR_COMPETITION

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3597, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3597, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__pyx_t_1) {
/* … */
      goto __pyx_L51;
    }

 3598:                 #print(f"Simulating first pass of respawn maneuver! Halt shooting status is {self.halt_shooting}, {fire_first_timestep=}")  # REMOVE_FOR_COMPETITION

+3599:                 assert self.halt_shooting  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3599, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3599, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_1)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 3599, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 3599, __pyx_L1_error)
      #endif

+3600:                 assert not self.fire_first_timestep  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_first_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3600, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3600, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_13 = (!__pyx_t_1);
        if (unlikely(!__pyx_t_13)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 3600, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 3600, __pyx_L1_error)
      #endif

+3601:             elif self.respawn_maneuver_pass_number == 2:  # REMOVE_FOR_COMPETITION

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3601, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_13 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, 2, 0)); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 3601, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__pyx_t_13) {
/* … */
    }
    __pyx_L51:;

 3602:                 #print(f"Simulating second pass of respawn maneuver! Halt shooting status is {self.halt_shooting}, {fire_first_timestep=}")  # REMOVE_FOR_COMPETITION

+3603:                 assert self.halt_shooting  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3603, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 3603, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_13)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 3603, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 3603, __pyx_L1_error)
      #endif

+3604:                 assert not self.fire_first_timestep  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_first_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3604, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 3604, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_1 = (!__pyx_t_13);
        if (unlikely(!__pyx_t_1)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 3604, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 3604, __pyx_L1_error)
      #endif

 3605:         # Define the random walks for shooting while maneuvering

 3606:         # If we just do a random walk (bias = 0.5), we get a normal distribution. If we do a uniformly distributed bias, then the final random walk will also be uniformly distributed!

+3607:         bias = random.random()

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3607, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_v_bias = __pyx_t_4;
  __pyx_t_4 = 0;

+3608:         self.random_walk_schedule: list[bool] = [random.random() < bias for _ in range(RANDOM_WALK_SCHEDULE_LENGTH)] # True means left, False means right. For shot number n, self.random_walk_schedule[n] tells us which direction we need to do the turning to make the shot in.

  { /* enter inner scope */
    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3608, __pyx_L54_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_7 = NULL;
    __Pyx_INCREF(__pyx_builtin_range);
    __pyx_t_2 = __pyx_builtin_range; 
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RANDOM_WALK_SCHEDULE_LENGTH); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3608, __pyx_L54_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3};
      __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3608, __pyx_L54_error)
      __Pyx_GOTREF(__pyx_t_8);
    }
    if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) {
      __pyx_t_2 = __pyx_t_8; __Pyx_INCREF(__pyx_t_2);
      __pyx_t_9 = 0;
      __pyx_t_14 = NULL;
    } else {
      __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3608, __pyx_L54_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_14 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3608, __pyx_L54_error)
    }
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    for (;;) {
      if (likely(!__pyx_t_14)) {
        if (likely(PyList_CheckExact(__pyx_t_2))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3608, __pyx_L54_error)
            #endif
            if (__pyx_t_9 >= __pyx_temp) break;
          }
          __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_9);
          ++__pyx_t_9;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3608, __pyx_L54_error)
            #endif
            if (__pyx_t_9 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9));
          #else
          __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9);
          #endif
          ++__pyx_t_9;
        }
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3608, __pyx_L54_error)
      } else {
        __pyx_t_8 = __pyx_t_14(__pyx_t_2);
        if (unlikely(!__pyx_t_8)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3608, __pyx_L54_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_XDECREF_SET(__pyx_9genexpr27__pyx_v__, __pyx_t_8);
      __pyx_t_8 = 0;
      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3608, __pyx_L54_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3608, __pyx_L54_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_15))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_15);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_15, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3608, __pyx_L54_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __pyx_t_15 = PyObject_RichCompare(__pyx_t_8, __pyx_v_bias, Py_LT); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3608, __pyx_L54_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_15))) __PYX_ERR(0, 3608, __pyx_L54_error)
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_9genexpr27__pyx_v__); __pyx_9genexpr27__pyx_v__ = 0;
    goto __pyx_L58_exit_scope;
    __pyx_L54_error:;
    __Pyx_XDECREF(__pyx_9genexpr27__pyx_v__); __pyx_9genexpr27__pyx_v__ = 0;
    goto __pyx_L1_error;
    __pyx_L58_exit_scope:;
  } /* exit inner scope */
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_random_walk_schedule, __pyx_t_4) < 0) __PYX_ERR(0, 3608, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 3609: 

+3610:     def get_last_timestep_colliding(self) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_3get_last_timestep_colliding(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_3get_last_timestep_colliding = {"get_last_timestep_colliding", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_3get_last_timestep_colliding, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_3get_last_timestep_colliding(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_last_timestep_colliding (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3610, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3610, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_last_timestep_colliding", 0) < 0) __PYX_ERR(0, 3610, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_last_timestep_colliding", 1, 1, 1, i); __PYX_ERR(0, 3610, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3610, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_last_timestep_colliding", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3610, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_last_timestep_colliding", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_2get_last_timestep_colliding(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_2get_last_timestep_colliding(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_last_timestep_colliding", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3610, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3610, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_3get_last_timestep_colliding, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_last_timestep_collidi, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[147])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3610, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_last_timestep_colliding, __pyx_t_2) < 0) __PYX_ERR(0, 3610, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3611:         return self.last_timestep_colliding

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3611, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 3611, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3612: 

+3613:     def get_mine_positions_placed(self) -> set[tuple[float, float]]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_5get_mine_positions_placed(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_5get_mine_positions_placed = {"get_mine_positions_placed", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_5get_mine_positions_placed, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_5get_mine_positions_placed(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_mine_positions_placed (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3613, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3613, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_mine_positions_placed", 0) < 0) __PYX_ERR(0, 3613, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_mine_positions_placed", 1, 1, 1, i); __PYX_ERR(0, 3613, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3613, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_mine_positions_placed", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3613, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_mine_positions_placed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_4get_mine_positions_placed(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_4get_mine_positions_placed(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_mine_positions_placed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_set_tuple_float_float) < 0) __PYX_ERR(0, 3613, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_5get_mine_positions_placed, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_mine_positions_placed, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[148])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_mine_positions_placed, __pyx_t_3) < 0) __PYX_ERR(0, 3613, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3614:         return self.mine_positions_placed

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3614, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_1))) __PYX_ERR(0, 3614, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3615: 

+3616:     def get_cancel_firing_first_timestep(self) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_7get_cancel_firing_first_timestep(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_7get_cancel_firing_first_timestep = {"get_cancel_firing_first_timestep", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_7get_cancel_firing_first_timestep, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_7get_cancel_firing_first_timestep(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_cancel_firing_first_timestep (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3616, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3616, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_cancel_firing_first_timestep", 0) < 0) __PYX_ERR(0, 3616, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_cancel_firing_first_timestep", 1, 1, 1, i); __PYX_ERR(0, 3616, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3616, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_cancel_firing_first_timestep", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3616, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_cancel_firing_first_timestep", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_6get_cancel_firing_first_timestep(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_6get_cancel_firing_first_timestep(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_cancel_firing_first_timestep", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3616, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_7get_cancel_firing_first_timestep, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_cancel_firing_first_t, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[149])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_cancel_firing_first_timestep, __pyx_t_2) < 0) __PYX_ERR(0, 3616, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3617:         return self.cancel_firing_first_timestep

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cancel_firing_first_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3617, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3618: 

+3619:     def get_explanations(self) -> list[str]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_9get_explanations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_9get_explanations = {"get_explanations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_9get_explanations, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_9get_explanations(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_explanations (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3619, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3619, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_explanations", 0) < 0) __PYX_ERR(0, 3619, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_explanations", 1, 1, 1, i); __PYX_ERR(0, 3619, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3619, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_explanations", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3619, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_explanations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_8get_explanations(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_8get_explanations(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_explanations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3619, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_str) < 0) __PYX_ERR(0, 3619, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_9get_explanations, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_explanations, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[150])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3619, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_explanations, __pyx_t_3) < 0) __PYX_ERR(0, 3619, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3620:         return self.explanation_messages

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3620, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 3620, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3621: 

+3622:     def get_safety_messages(self) -> list[str]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_safety_messages(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_safety_messages = {"get_safety_messages", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_11get_safety_messages, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_safety_messages(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_safety_messages (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3622, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3622, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_safety_messages", 0) < 0) __PYX_ERR(0, 3622, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_safety_messages", 1, 1, 1, i); __PYX_ERR(0, 3622, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3622, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_safety_messages", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3622, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_safety_messages", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_10get_safety_messages(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_10get_safety_messages(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_safety_messages", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3622, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_str) < 0) __PYX_ERR(0, 3622, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_safety_messages, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_safety_messages, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[151])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3622, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_safety_messages, __pyx_t_2) < 0) __PYX_ERR(0, 3622, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3623:         return self.safety_messages

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3623, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 3623, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3624: 

+3625:     def get_sim_id(self) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_13get_sim_id(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_13get_sim_id = {"get_sim_id", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_13get_sim_id, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_13get_sim_id(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_sim_id (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3625, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3625, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_sim_id", 0) < 0) __PYX_ERR(0, 3625, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_sim_id", 1, 1, 1, i); __PYX_ERR(0, 3625, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3625, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_sim_id", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3625, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_sim_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_12get_sim_id(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_12get_sim_id(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_sim_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3625, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3625, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_13get_sim_id, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_sim_id, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[152])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3625, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_sim_id, __pyx_t_3) < 0) __PYX_ERR(0, 3625, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3626:         return self.sim_id

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sim_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3626, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 3626, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3627: 

+3628:     def get_respawn_timer(self) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_15get_respawn_timer(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_15get_respawn_timer = {"get_respawn_timer", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_15get_respawn_timer, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_15get_respawn_timer(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_respawn_timer (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3628, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3628, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_respawn_timer", 0) < 0) __PYX_ERR(0, 3628, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_respawn_timer", 1, 1, 1, i); __PYX_ERR(0, 3628, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3628, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_respawn_timer", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3628, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_respawn_timer", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_14get_respawn_timer(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_14get_respawn_timer(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_respawn_timer", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3628, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_15get_respawn_timer, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_respawn_timer, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[153])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_respawn_timer, __pyx_t_2) < 0) __PYX_ERR(0, 3628, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3629:         return self.respawn_timer

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3629, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3630: 

+3631:     def get_ship_state(self) -> Ship:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_Ship *__pyx_pw_14neo_controller_6Matrix_17get_ship_state(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_17get_ship_state = {"get_ship_state", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_17get_ship_state, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static struct __pyx_obj_14neo_controller_Ship *__pyx_pw_14neo_controller_6Matrix_17get_ship_state(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_Ship *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_ship_state (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3631, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3631, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_ship_state", 0) < 0) __PYX_ERR(0, 3631, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_ship_state", 1, 1, 1, i); __PYX_ERR(0, 3631, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3631, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_ship_state", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3631, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_ship_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_16get_ship_state(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_Ship *__pyx_pf_14neo_controller_6Matrix_16get_ship_state(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_14neo_controller_Ship *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.Matrix.get_ship_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 3631, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_17get_ship_state, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_ship_state, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[154])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_ship_state, __pyx_t_3) < 0) __PYX_ERR(0, 3631, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3632:         return self.ship_state.copy()

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3632, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship))))) __PYX_ERR(0, 3632, __pyx_L1_error)
  __pyx_r = ((struct __pyx_obj_14neo_controller_Ship *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3633: 

+3634:     def get_game_state(self) -> GameState:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_GameState *__pyx_pw_14neo_controller_6Matrix_19get_game_state(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_19get_game_state = {"get_game_state", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_19get_game_state, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static struct __pyx_obj_14neo_controller_GameState *__pyx_pw_14neo_controller_6Matrix_19get_game_state(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_GameState *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_game_state (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3634, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3634, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_game_state", 0) < 0) __PYX_ERR(0, 3634, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_game_state", 1, 1, 1, i); __PYX_ERR(0, 3634, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3634, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_game_state", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3634, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_game_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_18get_game_state(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_GameState *__pyx_pf_14neo_controller_6Matrix_18get_game_state(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_14neo_controller_GameState *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.Matrix.get_game_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 3634, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_19get_game_state, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_game_state, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[155])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_game_state, __pyx_t_2) < 0) __PYX_ERR(0, 3634, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3635:         if self.backed_up_game_state_before_post_mutation is not None:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backed_up_game_state_before_post); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3635, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__pyx_t_1 != Py_None);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

 3636:             # In the process of waiting out mines, the game state got messed up so we have to use a backed-up copy

+3637:             return self.backed_up_game_state_before_post_mutation.copy()

    __Pyx_XDECREF((PyObject *)__pyx_r);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backed_up_game_state_before_post); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3637, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __pyx_t_4;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3637, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState))))) __PYX_ERR(0, 3637, __pyx_L1_error)
    __pyx_r = ((struct __pyx_obj_14neo_controller_GameState *)__pyx_t_1);
    __pyx_t_1 = 0;
    goto __pyx_L0;

 3638:         else:

+3639:             return self.game_state.copy()

  /*else*/ {
    __Pyx_XDECREF((PyObject *)__pyx_r);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3639, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __pyx_t_3;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3639, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState))))) __PYX_ERR(0, 3639, __pyx_L1_error)
    __pyx_r = ((struct __pyx_obj_14neo_controller_GameState *)__pyx_t_1);
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

 3640: 

+3641:     def get_fire_next_timestep_flag(self) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_21get_fire_next_timestep_flag(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_21get_fire_next_timestep_flag = {"get_fire_next_timestep_flag", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_21get_fire_next_timestep_flag, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_21get_fire_next_timestep_flag(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_fire_next_timestep_flag (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3641, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3641, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_fire_next_timestep_flag", 0) < 0) __PYX_ERR(0, 3641, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_fire_next_timestep_flag", 1, 1, 1, i); __PYX_ERR(0, 3641, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3641, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_fire_next_timestep_flag", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3641, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fire_next_timestep_flag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_20get_fire_next_timestep_flag(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_20get_fire_next_timestep_flag(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fire_next_timestep_flag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3641, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3641, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_21get_fire_next_timestep_flag, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fire_next_timestep_fl, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[156])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3641, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_fire_next_timestep_flag, __pyx_t_3) < 0) __PYX_ERR(0, 3641, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3642:         return self.fire_next_timestep_flag

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3643: 

+3644:     def set_fire_next_timestep_flag(self, fire_next_timestep_flag: bool) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_23set_fire_next_timestep_flag(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_23set_fire_next_timestep_flag = {"set_fire_next_timestep_flag", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_23set_fire_next_timestep_flag, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_23set_fire_next_timestep_flag(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_fire_next_timestep_flag = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("set_fire_next_timestep_flag (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3644, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3644, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3644, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_fire_next_timestep_flag", 0) < 0) __PYX_ERR(0, 3644, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_fire_next_timestep_flag", 1, 2, 2, i); __PYX_ERR(0, 3644, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3644, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3644, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_fire_next_timestep_flag = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("set_fire_next_timestep_flag", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3644, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.set_fire_next_timestep_flag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_22set_fire_next_timestep_flag(__pyx_self, __pyx_v_self, __pyx_v_fire_next_timestep_flag);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_22set_fire_next_timestep_flag(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_fire_next_timestep_flag) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.Matrix.set_fire_next_timestep_flag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3644, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 3644, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_23set_fire_next_timestep_flag, 0, __pyx_mstate_global->__pyx_n_u_Matrix_set_fire_next_timestep_fl, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[157])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_set_fire_next_timestep_flag, __pyx_t_2) < 0) __PYX_ERR(0, 3644, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3645:         self.fire_next_timestep_flag = fire_next_timestep_flag

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, __pyx_v_fire_next_timestep_flag) < 0) __PYX_ERR(0, 3645, __pyx_L1_error)

 3646: 

+3647:     def get_asteroids_pending_death(self) -> dict[int, list[Asteroid]]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_25get_asteroids_pending_death(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_25get_asteroids_pending_death = {"get_asteroids_pending_death", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_25get_asteroids_pending_death, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_25get_asteroids_pending_death(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_asteroids_pending_death (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3647, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3647, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_asteroids_pending_death", 0) < 0) __PYX_ERR(0, 3647, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_asteroids_pending_death", 1, 1, 1, i); __PYX_ERR(0, 3647, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3647, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_asteroids_pending_death", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3647, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_asteroids_pending_death", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_24get_asteroids_pending_death(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_24get_asteroids_pending_death(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_asteroids_pending_death", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_dict_int_list_Asteroid) < 0) __PYX_ERR(0, 3647, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_25get_asteroids_pending_death, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_asteroids_pending_dea, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[158])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_asteroids_pending_death, __pyx_t_3) < 0) __PYX_ERR(0, 3647, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+3648:         return self.asteroids_pending_death

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3648, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(0, 3648, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3649: 

+3650:     def get_forecasted_asteroid_splits(self) -> list[Asteroid]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_27get_forecasted_asteroid_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_27get_forecasted_asteroid_splits = {"get_forecasted_asteroid_splits", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_27get_forecasted_asteroid_splits, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_27get_forecasted_asteroid_splits(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_forecasted_asteroid_splits (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3650, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3650, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_forecasted_asteroid_splits", 0) < 0) __PYX_ERR(0, 3650, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_forecasted_asteroid_splits", 1, 1, 1, i); __PYX_ERR(0, 3650, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3650, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_forecasted_asteroid_splits", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3650, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_forecasted_asteroid_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_26get_forecasted_asteroid_splits(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_26get_forecasted_asteroid_splits(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_forecasted_asteroid_splits", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3650, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Asteroid) < 0) __PYX_ERR(0, 3650, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_27get_forecasted_asteroid_splits, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_forecasted_asteroid_s, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[159])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3650, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_forecasted_asteroid_splits, __pyx_t_2) < 0) __PYX_ERR(0, 3650, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3651:         return self.forecasted_asteroid_splits

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3651, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 3651, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3652: 

+3653:     def get_instantaneous_asteroid_collision(self, asteroids: Optional[list[Asteroid]] = None, ship_position: Optional[tuple[float, float]] = None) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_29get_instantaneous_asteroid_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_29get_instantaneous_asteroid_collision = {"get_instantaneous_asteroid_collision", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_29get_instantaneous_asteroid_collision, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_29get_instantaneous_asteroid_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_asteroids = 0;
  PyObject *__pyx_v_ship_position = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_instantaneous_asteroid_collision (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_asteroids,&__pyx_mstate_global->__pyx_n_u_ship_position,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3653, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3653, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3653, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3653, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_instantaneous_asteroid_collision", 0) < 0) __PYX_ERR(0, 3653, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_instantaneous_asteroid_collision", 0, 1, 3, i); __PYX_ERR(0, 3653, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3653, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3653, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3653, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject*)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_asteroids = ((PyObject*)values[1]);
    __pyx_v_ship_position = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_instantaneous_asteroid_collision", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 3653, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_instantaneous_asteroid_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids), (&PyList_Type), 1, "asteroids", 2))) __PYX_ERR(0, 3653, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_position), (&PyTuple_Type), 1, "ship_position", 2))) __PYX_ERR(0, 3653, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_28get_instantaneous_asteroid_collision(__pyx_self, __pyx_v_self, __pyx_v_asteroids, __pyx_v_ship_position);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_28get_instantaneous_asteroid_collision(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_asteroids, PyObject *__pyx_v_ship_position) {
  PyObject *__pyx_v_position = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("neo_controller.Matrix.get_instantaneous_asteroid_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_position);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3653, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_mstate_global->__pyx_kp_u_Optional_list_Asteroid) < 0) __PYX_ERR(0, 3653, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_position, __pyx_mstate_global->__pyx_kp_u_Optional_tuple_float_float) < 0) __PYX_ERR(0, 3653, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3653, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_29get_instantaneous_asteroid_collision, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_instantaneous_asteroi, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[160])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3653, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[91]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_instantaneous_asteroid_colli, __pyx_t_3) < 0) __PYX_ERR(0, 3653, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[91] = PyTuple_Pack(2, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[91])) __PYX_ERR(0, 3653, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[91]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[91]);

 3654:         # UNUSED

+3655:         if ship_position is not None:

  __pyx_t_1 = (__pyx_v_ship_position != ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
    goto __pyx_L3;
  }

+3656:             position = ship_position

    __Pyx_INCREF(__pyx_v_ship_position);
    __pyx_v_position = __pyx_v_ship_position;

 3657:         else:

+3658:             position = self.ship_state.position

  /*else*/ {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3658, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3658, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_position = __pyx_t_3;
    __pyx_t_3 = 0;
  }
  __pyx_L3:;

 3659: 

+3660:         for a in (asteroids if asteroids is not None else self.game_state.asteroids):

  __pyx_t_1 = (__pyx_v_asteroids != ((PyObject*)Py_None));
  if (__pyx_t_1) {
    __Pyx_INCREF(__pyx_v_asteroids);
    __pyx_t_3 = __pyx_v_asteroids;
  } else {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3660, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3660, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_3 = __pyx_t_4;
    __pyx_t_4 = 0;
  }
  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
    __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3660, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3660, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  for (;;) {
    if (likely(!__pyx_t_6)) {
      if (likely(PyList_CheckExact(__pyx_t_4))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3660, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_5);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3660, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5));
        #else
        __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3660, __pyx_L1_error)
    } else {
      __pyx_t_3 = __pyx_t_6(__pyx_t_4);
      if (unlikely(!__pyx_t_3)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3660, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3661:             if check_collision(position[0], position[1], SHIP_RADIUS, a.position[0], a.position[1], a.radius):

    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_check_collision); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_11, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_11, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_14 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_7))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
      __pyx_t_14 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[7] = {__pyx_t_2, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_12, __pyx_t_13, __pyx_t_11};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_14, (7-__pyx_t_14) | (__pyx_t_14*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3661, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3661, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_1) {
/* … */
    }

+3662:                 return True

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_True);
      __pyx_r = Py_True;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      goto __pyx_L0;

+3663:         return False

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_False);
  __pyx_r = Py_False;
  goto __pyx_L0;

 3664: 

+3665:     def get_instantaneous_ship_collision(self) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_31get_instantaneous_ship_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_31get_instantaneous_ship_collision = {"get_instantaneous_ship_collision", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_31get_instantaneous_ship_collision, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_31get_instantaneous_ship_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_instantaneous_ship_collision (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3665, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3665, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_instantaneous_ship_collision", 0) < 0) __PYX_ERR(0, 3665, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_instantaneous_ship_collision", 1, 1, 1, i); __PYX_ERR(0, 3665, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3665, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_instantaneous_ship_collision", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3665, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_instantaneous_ship_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_30get_instantaneous_ship_collision(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_30get_instantaneous_ship_collision(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_ship = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("neo_controller.Matrix.get_instantaneous_ship_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ship);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3665, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_31get_instantaneous_ship_collision, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_instantaneous_ship_co, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[161])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_instantaneous_ship_collision, __pyx_t_2) < 0) __PYX_ERR(0, 3665, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3666:         # UNUSED. This is too inaccurate, and there's better ways to handle avoiding the other ship rather than being overconfident in giving a binary yes you will collide/no you will not collide

+3667:         for ship in self.other_ships:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3667, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3667, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3667, __pyx_L1_error)
          #endif
          if (__pyx_t_3 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3);
        ++__pyx_t_3;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3667, __pyx_L1_error)
          #endif
          if (__pyx_t_3 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3);
        #endif
        ++__pyx_t_3;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3667, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_4(__pyx_t_2);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3667, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_ship, __pyx_t_1);
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3668:             # The faster the other ship is going, the bigger of a bubble around it I'm going to draw, since they can deviate from their path very quickly and run into me even though I thought I was in the clear

+3669:             if check_collision(self.ship_state.position[0], self.ship_state.position[1], SHIP_RADIUS, ship.position[0], ship.position[1], ship.radius + SHIP_AVOIDANCE_PADDING + sqrt(ship.velocity[0]**2 + ship.velocity[1]**2)*SHIP_AVOIDANCE_SPEED_PADDING_RATIO):

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_check_collision); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_SHIP_AVOIDANCE_PADDING); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_14 = PyNumber_Add(__pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __pyx_t_13 = PyNumber_Power(__pyx_t_10, __pyx_mstate_global->__pyx_int_2, Py_None); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyNumber_Power(__pyx_t_15, __pyx_mstate_global->__pyx_int_2, Py_None); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_t_15 = PyNumber_Add(__pyx_t_13, __pyx_t_10); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_16 = __Pyx_PyFloat_AsDouble(__pyx_t_15); if (unlikely((__pyx_t_16 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_t_15 = PyFloat_FromDouble(sqrt(__pyx_t_16)); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_AVOIDANCE_SPEED_PADDING_RAT); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_13 = PyNumber_Multiply(__pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyNumber_Add(__pyx_t_14, __pyx_t_13); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __pyx_t_17 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_17 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[7] = {__pyx_t_5, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_11, __pyx_t_12, __pyx_t_10};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_17, (7-__pyx_t_17) | (__pyx_t_17*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3669, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 3669, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_18) {
/* … */
    }

+3670:                 return True

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_True);
      __pyx_r = Py_True;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      goto __pyx_L0;

+3671:         return False

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_False);
  __pyx_r = Py_False;
  goto __pyx_L0;

 3672: 

+3673:     def get_instantaneous_mine_collision(self) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_33get_instantaneous_mine_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_33get_instantaneous_mine_collision = {"get_instantaneous_mine_collision", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_33get_instantaneous_mine_collision, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_33get_instantaneous_mine_collision(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_instantaneous_mine_collision (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3673, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3673, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_instantaneous_mine_collision", 0) < 0) __PYX_ERR(0, 3673, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_instantaneous_mine_collision", 1, 1, 1, i); __PYX_ERR(0, 3673, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3673, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_instantaneous_mine_collision", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3673, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_instantaneous_mine_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_32get_instantaneous_mine_collision(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_32get_instantaneous_mine_collision(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  int __pyx_v_mine_collision;
  PyObject *__pyx_v_mine_remove_idxs = NULL;
  PyObject *__pyx_v_i = NULL;
  PyObject *__pyx_v_m = NULL;
  PyObject *__pyx_9genexpr28__pyx_v_idx = NULL;
  PyObject *__pyx_9genexpr28__pyx_v_mine = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_AddTraceback("neo_controller.Matrix.get_instantaneous_mine_collision", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mine_remove_idxs);
  __Pyx_XDECREF(__pyx_v_i);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XDECREF(__pyx_9genexpr28__pyx_v_idx);
  __Pyx_XDECREF(__pyx_9genexpr28__pyx_v_mine);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3673, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_33get_instantaneous_mine_collision, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_instantaneous_mine_co, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[162])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_instantaneous_mine_collision, __pyx_t_3) < 0) __PYX_ERR(0, 3673, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 3674:         # UNUSED

+3675:         mine_collision = False

  __pyx_v_mine_collision = 0;

+3676:         mine_remove_idxs = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_mine_remove_idxs = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+3677:         for i, m in enumerate(self.game_state.mines):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_1 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3677, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3677, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
    __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = 0;
    __pyx_t_5 = NULL;
  } else {
    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3677, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3677, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  for (;;) {
    if (likely(!__pyx_t_5)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3677, __pyx_L1_error)
          #endif
          if (__pyx_t_4 >= __pyx_temp) break;
        }
        __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4);
        ++__pyx_t_4;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3677, __pyx_L1_error)
          #endif
          if (__pyx_t_4 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4));
        #else
        __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4);
        #endif
        ++__pyx_t_4;
      }
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3677, __pyx_L1_error)
    } else {
      __pyx_t_3 = __pyx_t_5(__pyx_t_2);
      if (unlikely(!__pyx_t_3)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3677, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_3);
    __pyx_t_3 = 0;
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1);
    __pyx_t_3 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3677, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1);
    __pyx_t_1 = __pyx_t_3;
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3678:             if m.remaining_time < EPS:

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3678, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3678, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_8) {
/* … */
    }

+3679:                 if check_collision(self.ship_state.position[0], self.ship_state.position[1], SHIP_RADIUS, m.position[0], m.position[1], MINE_BLAST_RADIUS):

      __pyx_t_6 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_check_collision); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_11, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_12, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_14 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_15 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_6);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_15 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[7] = {__pyx_t_6, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_13, __pyx_t_14, __pyx_t_12};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_15, (7-__pyx_t_15) | (__pyx_t_15*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3679, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3679, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (__pyx_t_8) {
/* … */
      }

+3680:                     mine_collision = True

        __pyx_v_mine_collision = 1;

+3681:                 mine_remove_idxs.append(i)

      __pyx_t_16 = __Pyx_PyList_Append(__pyx_v_mine_remove_idxs, __pyx_v_i); if (unlikely(__pyx_t_16 == ((int)-1))) __PYX_ERR(0, 3681, __pyx_L1_error)

+3682:         if mine_remove_idxs:

  __pyx_t_8 = (__Pyx_PyList_GET_SIZE(__pyx_v_mine_remove_idxs) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_8 < 0))) __PYX_ERR(0, 3682, __pyx_L1_error)
  if (__pyx_t_8) {
/* … */
  }

+3683:             self.game_state.mines = [mine for idx, mine in enumerate(self.game_state.mines) if idx not in mine_remove_idxs]

    { /* enter inner scope */
      __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3683, __pyx_L11_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3683, __pyx_L11_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3683, __pyx_L11_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
        __pyx_t_7 = __pyx_t_3; __Pyx_INCREF(__pyx_t_7);
        __pyx_t_4 = 0;
        __pyx_t_5 = NULL;
      } else {
        __pyx_t_4 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3683, __pyx_L11_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3683, __pyx_L11_error)
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      for (;;) {
        if (likely(!__pyx_t_5)) {
          if (likely(PyList_CheckExact(__pyx_t_7))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3683, __pyx_L11_error)
              #endif
              if (__pyx_t_4 >= __pyx_temp) break;
            }
            __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_4);
            ++__pyx_t_4;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3683, __pyx_L11_error)
              #endif
              if (__pyx_t_4 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_4));
            #else
            __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_4);
            #endif
            ++__pyx_t_4;
          }
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3683, __pyx_L11_error)
        } else {
          __pyx_t_3 = __pyx_t_5(__pyx_t_7);
          if (unlikely(!__pyx_t_3)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3683, __pyx_L11_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_XDECREF_SET(__pyx_9genexpr28__pyx_v_mine, __pyx_t_3);
        __pyx_t_3 = 0;
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_XDECREF_SET(__pyx_9genexpr28__pyx_v_idx, __pyx_t_2);
        __pyx_t_3 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3683, __pyx_L11_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_2);
        __pyx_t_2 = __pyx_t_3;
        __pyx_t_3 = 0;
        __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_9genexpr28__pyx_v_idx, __pyx_v_mine_remove_idxs, Py_NE)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3683, __pyx_L11_error)
        if (__pyx_t_8) {
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_9genexpr28__pyx_v_mine))) __PYX_ERR(0, 3683, __pyx_L11_error)
        }
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF(__pyx_9genexpr28__pyx_v_idx); __pyx_9genexpr28__pyx_v_idx = 0;
      __Pyx_XDECREF(__pyx_9genexpr28__pyx_v_mine); __pyx_9genexpr28__pyx_v_mine = 0;
      goto __pyx_L16_exit_scope;
      __pyx_L11_error:;
      __Pyx_XDECREF(__pyx_9genexpr28__pyx_v_idx); __pyx_9genexpr28__pyx_v_idx = 0;
      __Pyx_XDECREF(__pyx_9genexpr28__pyx_v_mine); __pyx_9genexpr28__pyx_v_mine = 0;
      goto __pyx_L1_error;
      __pyx_L16_exit_scope:;
    } /* exit inner scope */
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3683, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mines, __pyx_t_1) < 0) __PYX_ERR(0, 3683, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3684:         return mine_collision

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_mine_collision); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3684, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 3685: 

+3686:     def get_next_extrapolated_asteroid_collision_time(self, additional_timesteps_to_blow_up_mines: int = 0) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_35get_next_extrapolated_asteroid_collision_time(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_35get_next_extrapolated_asteroid_collision_time = {"get_next_extrapolated_asteroid_collision_time", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_35get_next_extrapolated_asteroid_collision_time, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_35get_next_extrapolated_asteroid_collision_time(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_additional_timesteps_to_blow_up_mines = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_next_extrapolated_asteroid_collision_time (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_additional_timesteps_to_blow_up,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3686, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3686, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3686, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_next_extrapolated_asteroid_collision_time", 0) < 0) __PYX_ERR(0, 3686, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_next_extrapolated_asteroid_collision_time", 0, 1, 2, i); __PYX_ERR(0, 3686, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3686, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3686, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
    }
    __pyx_v_self = values[0];
    __pyx_v_additional_timesteps_to_blow_up_mines = ((PyObject*)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_next_extrapolated_asteroid_collision_time", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3686, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_next_extrapolated_asteroid_collision_time", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_additional_timesteps_to_blow_up_mines), (&PyLong_Type), 0, "additional_timesteps_to_blow_up_mines", 2))) __PYX_ERR(0, 3686, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_34get_next_extrapolated_asteroid_collision_time(__pyx_self, __pyx_v_self, __pyx_v_additional_timesteps_to_blow_up_mines);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_34get_next_extrapolated_asteroid_collision_time(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_additional_timesteps_to_blow_up_mines) {
  PyObject *__pyx_v_next_imminent_asteroid_collision_time = NULL;
  PyObject *__pyx_v_ast_idx = NULL;
  PyObject *__pyx_v_asteroid = NULL;
  PyObject *__pyx_v_asteroid_is_born = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_predicted_collision_time_from_future = NULL;
  PyObject *__pyx_v_predicted_collision_time = NULL;
  PyObject *__pyx_v_ast_to_check = NULL;
  PyObject *__pyx_v_predicted_collision_ts = NULL;
  PyObject *__pyx_v_future_asteroid_during_imminent_collision_time = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_24);
  __Pyx_XDECREF(__pyx_t_25);
  __Pyx_AddTraceback("neo_controller.Matrix.get_next_extrapolated_asteroid_collision_time", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_next_imminent_asteroid_collision_time);
  __Pyx_XDECREF(__pyx_v_ast_idx);
  __Pyx_XDECREF(__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_v_asteroid_is_born);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_predicted_collision_time_from_future);
  __Pyx_XDECREF(__pyx_v_predicted_collision_time);
  __Pyx_XDECREF(__pyx_v_ast_to_check);
  __Pyx_XDECREF(__pyx_v_predicted_collision_ts);
  __Pyx_XDECREF(__pyx_v_future_asteroid_during_imminent_collision_time);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3686, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_additional_timesteps_to_blow_up, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3686, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3686, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_35get_next_extrapolated_asteroid_collision_time, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_next_extrapolated_ast, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[163])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3686, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[18]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_next_extrapolated_asteroid_c, __pyx_t_2) < 0) __PYX_ERR(0, 3686, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3687:         # debug_print(f"Inside get fitness, we shot {self.asteroids_shot} asteroids. getting extrapolated collision time. The ship's velocity is: ({self.ship_state.velocity[0]}, {self.ship_state.velocity[1]})")

 3688:         # Assume constant velocity from here

+3689:         next_imminent_asteroid_collision_time = INFINITY

  __pyx_t_1 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3689, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_next_imminent_asteroid_collision_time = __pyx_t_1;
  __pyx_t_1 = 0;

 3690:         # print('Extrapolating stuff at rest in end')

 3691:         # The asteroids from the game state could have been from the future since we waited out the mines, but the forecasted splits are from present time, so we need to treat them differently and only back-extrapolate the existing asteroids and not the forecasted ones

 3692:         # print(f"Forecasted splits: {self.forecasted_asteroid_splits}")

+3693:         for ast_idx, asteroid in enumerate(chain(self.game_state.asteroids, self.forecasted_asteroid_splits)):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_1 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3693, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3693, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3693, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3693, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_6, __pyx_t_5};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3693, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4);
    __pyx_t_8 = 0;
    __pyx_t_9 = NULL;
  } else {
    __pyx_t_8 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3693, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3693, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_9)) {
      if (likely(PyList_CheckExact(__pyx_t_4))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3693, __pyx_L1_error)
          #endif
          if (__pyx_t_8 >= __pyx_temp) break;
        }
        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_8);
        ++__pyx_t_8;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3693, __pyx_L1_error)
          #endif
          if (__pyx_t_8 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_8));
        #else
        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_8);
        #endif
        ++__pyx_t_8;
      }
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3693, __pyx_L1_error)
    } else {
      __pyx_t_2 = __pyx_t_9(__pyx_t_4);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3693, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_2);
    __pyx_t_2 = 0;
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_ast_idx, __pyx_t_1);
    __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3693, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1);
    __pyx_t_1 = __pyx_t_2;
    __pyx_t_2 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+3694:             asteroid_is_born: bool = ast_idx < len(self.game_state.asteroids)

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3694, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3694, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_10 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3694, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyLong_FromSsize_t(__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3694, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_2 = PyObject_RichCompare(__pyx_v_ast_idx, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3694, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF_SET(__pyx_v_asteroid_is_born, __pyx_t_2);
    __pyx_t_2 = 0;

 3695:             # print(f"Ast is born: {asteroid_is_born}")

 3696:             # print(f"Checking collision with asteroid: {ast_to_string(asteroid)} on timestep {self.initial_timestep + self.future_timesteps}")

 3697:             # debug_print(f"Future timesteps: {self.future_timesteps}, timesteps to not check collision for: {self.timesteps_to_not_check_collision_for}")

+3698:             for a in unwrap_asteroid(asteroid, self.game_state.map_size[0], self.game_state.map_size[1], UNWRAP_ASTEROID_COLLISION_FORECAST_TIME_HORIZON, False):

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_unwrap_asteroid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_11, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_12, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_UNWRAP_ASTEROID_COLLISION_FORECA); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3698, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[6] = {__pyx_t_5, __pyx_v_asteroid, __pyx_t_3, __pyx_t_11, __pyx_t_12, Py_False};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (6-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3698, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
      __pyx_t_6 = __pyx_t_2; __Pyx_INCREF(__pyx_t_6);
      __pyx_t_10 = 0;
      __pyx_t_13 = NULL;
    } else {
      __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3698, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 3698, __pyx_L1_error)
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    for (;;) {
      if (likely(!__pyx_t_13)) {
        if (likely(PyList_CheckExact(__pyx_t_6))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3698, __pyx_L1_error)
            #endif
            if (__pyx_t_10 >= __pyx_temp) break;
          }
          __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_10);
          ++__pyx_t_10;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3698, __pyx_L1_error)
            #endif
            if (__pyx_t_10 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10));
          #else
          __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_10);
          #endif
          ++__pyx_t_10;
        }
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3698, __pyx_L1_error)
      } else {
        __pyx_t_2 = __pyx_t_13(__pyx_t_6);
        if (unlikely(!__pyx_t_2)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3698, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_2);
      __pyx_t_2 = 0;
/* … */
      __pyx_L5_continue:;
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 3699:                 # if self.future_timesteps >= self.timesteps_to_not_check_collision_for:

+3700:                 assert is_close_to_zero(self.ship_state.velocity[0]) and is_close_to_zero(self.ship_state.velocity[1]), f"{self.ship_state.velocity=}, {self.ship_state.speed=}"  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_12 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_7 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_11))) {
          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
          assert(__pyx_t_12);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
          __Pyx_INCREF(__pyx_t_12);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
          __pyx_t_7 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_3};
          __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (__pyx_t_15) {
        } else {
          __pyx_t_14 = __pyx_t_15;
          goto __pyx_L7_bool_binop_done;
        }
        __pyx_t_11 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_7 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3);
          assert(__pyx_t_11);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_11);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
          __pyx_t_7 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_12};
          __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 3700, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_14 = __pyx_t_15;
        __pyx_L7_bool_binop_done:;
        if (unlikely(!__pyx_t_14)) {
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_3), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_12);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_12), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          __pyx_t_16[0] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_velocity;
          __pyx_t_16[1] = __pyx_t_2;
          __pyx_t_16[2] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_speed;
          __pyx_t_16[3] = __pyx_t_3;
          __pyx_t_12 = __Pyx_PyUnicode_Join(__pyx_t_16, 4, 25 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 24 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3));
          if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3700, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_12);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_12, 0, 0);
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          __PYX_ERR(0, 3700, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 3700, __pyx_L1_error)
      #endif

 3701: 

+3702:                 predicted_collision_time_from_future = predict_next_imminent_collision_time_with_asteroid(self.ship_state.position[0], self.ship_state.position[1], self.ship_state.velocity[0], self.ship_state.velocity[1], SHIP_RADIUS, a.position[0], a.position[1], a.velocity[0], a.velocity[1], a.radius, self.game_state)

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_predict_next_imminent_collision); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_17, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __pyx_t_17 = __Pyx_GetItemInt(__pyx_t_18, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_19, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_20, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_20, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_20, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_24 = __Pyx_GetItemInt(__pyx_t_20, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_2))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[12] = {__pyx_t_3, __pyx_t_11, __pyx_t_5, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24, __pyx_t_20, __pyx_t_25};
        __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (12-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3702, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_12);
      }
      __Pyx_XDECREF_SET(__pyx_v_predicted_collision_time_from_future, __pyx_t_12);
      __pyx_t_12 = 0;

+3703:                 predicted_collision_time = predicted_collision_time_from_future + (DELTA_TIME*float(additional_timesteps_to_blow_up_mines) if asteroid_is_born else 0.0)

      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_asteroid_is_born); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3703, __pyx_L1_error)
      if (__pyx_t_14) {
        __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3703, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_26 = PyLong_AsDouble(__pyx_v_additional_timesteps_to_blow_up_mines); if (unlikely(__pyx_t_26 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3703, __pyx_L1_error)
        __pyx_t_25 = PyFloat_FromDouble(__pyx_t_26); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3703, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_20 = PyNumber_Multiply(__pyx_t_2, __pyx_t_25); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3703, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_t_12 = __pyx_t_20;
        __pyx_t_20 = 0;
      } else {
        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __pyx_t_12 = __pyx_mstate_global->__pyx_float_0_0;
      }
      __pyx_t_20 = PyNumber_Add(__pyx_v_predicted_collision_time_from_future, __pyx_t_12); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3703, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF_SET(__pyx_v_predicted_collision_time, __pyx_t_20);
      __pyx_t_20 = 0;

 3704: 

+3705:                 if isinf(predicted_collision_time):

      __pyx_t_27 = __Pyx_PyFloat_AsDouble(__pyx_v_predicted_collision_time); if (unlikely((__pyx_t_27 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3705, __pyx_L1_error)
      __pyx_t_14 = (isinf(__pyx_t_27) != 0);
      if (__pyx_t_14) {
/* … */
      }

+3706:                     continue

        goto __pyx_L5_continue;

+3707:                 if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3707, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3707, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      if (__pyx_t_14) {
/* … */
      }

+3708:                     assert predicted_collision_time >= 0.0  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_20 = PyObject_RichCompare(__pyx_v_predicted_collision_time, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_20); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3708, __pyx_L1_error)
          __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3708, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          if (unlikely(!__pyx_t_14)) {
            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
            __PYX_ERR(0, 3708, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 3708, __pyx_L1_error)
        #endif

 3709:                 # The predicted collision time is finite and after the end of the sim

 3710:                 # TODO: Verify there isn't an off by one error

+3711:                 if not (asteroid.timesteps_until_appearance > 0 and float(asteroid.timesteps_until_appearance)*DELTA_TIME > predicted_collision_time + EPS):

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_12 = PyObject_RichCompare(__pyx_t_20, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (__pyx_t_15) {
      } else {
        __pyx_t_14 = __pyx_t_15;
        goto __pyx_L12_bool_binop_done;
      }
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_timesteps_until_appearance); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_20 = __Pyx_PyNumber_Float(__pyx_t_12); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_25 = PyNumber_Multiply(__pyx_t_20, __pyx_t_12); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_12 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_20 = PyNumber_Add(__pyx_v_predicted_collision_time, __pyx_t_12); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_12 = PyObject_RichCompare(__pyx_t_25, __pyx_t_20, Py_GT); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 3711, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_14 = __pyx_t_15;
      __pyx_L12_bool_binop_done:;
      __pyx_t_15 = (!__pyx_t_14);
      if (__pyx_t_15) {
/* … */
      }

 3712:                     # The asteroid either exists, or will come into existence before our collision time

 3713:                     # Check the canonical asteroid, and not the unwrapped one!

 3714:                     # print(f"{additional_timesteps_to_blow_up_mines=}")

+3715:                     if asteroid_is_born and additional_timesteps_to_blow_up_mines != 0:

        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_asteroid_is_born); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3715, __pyx_L1_error)
        if (__pyx_t_14) {
        } else {
          __pyx_t_15 = __pyx_t_14;
          goto __pyx_L15_bool_binop_done;
        }
        __pyx_t_14 = (__Pyx_PyLong_BoolNeObjC(__pyx_v_additional_timesteps_to_blow_up_mines, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3715, __pyx_L1_error)
        __pyx_t_15 = __pyx_t_14;
        __pyx_L15_bool_binop_done:;
        if (__pyx_t_15) {
/* … */
          goto __pyx_L14;
        }

+3716:                         ast_to_check = time_travel_asteroid(asteroid, -additional_timesteps_to_blow_up_mines, self.game_state)

          __pyx_t_20 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3716, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_2 = PyNumber_Negative(__pyx_v_additional_timesteps_to_blow_up_mines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3716, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 3716, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_24);
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_25))) {
            __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_25);
            assert(__pyx_t_20);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_25);
            __Pyx_INCREF(__pyx_t_20);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_25, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_20, __pyx_v_asteroid, __pyx_t_2, __pyx_t_24};
            __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_25, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
            __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
            if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3716, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_12);
          }
          __Pyx_XDECREF_SET(__pyx_v_ast_to_check, __pyx_t_12);
          __pyx_t_12 = 0;

 3717:                     else:

+3718:                         ast_to_check = asteroid

        /*else*/ {
          __Pyx_INCREF(__pyx_v_asteroid);
          __Pyx_XDECREF_SET(__pyx_v_ast_to_check, __pyx_v_asteroid);
        }
        __pyx_L14:;

+3719:                     if not check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps, self.game_state, ast_to_check):

        __pyx_t_25 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_24, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 3719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_24);
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 3719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_22 = PyNumber_Add(__pyx_t_20, __pyx_t_23); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 3719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_7 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_24))) {
          __pyx_t_25 = PyMethod_GET_SELF(__pyx_t_24);
          assert(__pyx_t_25);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_24);
          __Pyx_INCREF(__pyx_t_25);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_24, __pyx__function);
          __pyx_t_7 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_25, __pyx_t_2, __pyx_t_22, __pyx_t_23, __pyx_v_ast_to_check};
          __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_24, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
          if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3719, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_12);
        }
        __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely((__pyx_t_15 < 0))) __PYX_ERR(0, 3719, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_14 = (!__pyx_t_15);
        if (__pyx_t_14) {
/* … */
          goto __pyx_L17;
        }

 3720:                         # We're already shooting the asteroid. Check whether the imminent collision time is before or after the asteroid is eliminated

+3721:                         predicted_collision_ts = floor(predicted_collision_time*FPS)

          __pyx_t_24 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 3721, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3721, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __pyx_t_2 = PyNumber_Multiply(__pyx_v_predicted_collision_time, __pyx_t_22); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3721, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_23))) {
            __pyx_t_24 = PyMethod_GET_SELF(__pyx_t_23);
            assert(__pyx_t_24);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
            __Pyx_INCREF(__pyx_t_24);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_24, __pyx_t_2};
            __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3721, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_12);
          }
          __Pyx_XDECREF_SET(__pyx_v_predicted_collision_ts, __pyx_t_12);
          __pyx_t_12 = 0;

+3722:                         if asteroid_is_born:

          __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_asteroid_is_born); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3722, __pyx_L1_error)
          if (__pyx_t_14) {
/* … */
            goto __pyx_L18;
          }

+3723:                             future_asteroid_during_imminent_collision_time = time_travel_asteroid(a, predicted_collision_ts - additional_timesteps_to_blow_up_mines, self.game_state)

            __pyx_t_23 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3723, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_24 = PyNumber_Subtract(__pyx_v_predicted_collision_ts, __pyx_v_additional_timesteps_to_blow_up_mines); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 3723, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_24);
            __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3723, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_22);
            __pyx_t_7 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_2))) {
              __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_2);
              assert(__pyx_t_23);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
              __Pyx_INCREF(__pyx_t_23);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
              __pyx_t_7 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_23, __pyx_v_a, __pyx_t_24, __pyx_t_22};
              __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
              __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
              __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3723, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_12);
            }
            __Pyx_XDECREF_SET(__pyx_v_future_asteroid_during_imminent_collision_time, __pyx_t_12);
            __pyx_t_12 = 0;

 3724:                         else:

+3725:                             future_asteroid_during_imminent_collision_time = time_travel_asteroid(a, predicted_collision_ts, self.game_state)

          /*else*/ {
            __pyx_t_2 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3725, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_22);
            __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 3725, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_24);
            __pyx_t_7 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_22))) {
              __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_22);
              assert(__pyx_t_2);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_22);
              __Pyx_INCREF(__pyx_t_2);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_22, __pyx__function);
              __pyx_t_7 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_v_a, __pyx_v_predicted_collision_ts, __pyx_t_24};
              __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_22, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
              __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
              __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
              if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3725, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_12);
            }
            __Pyx_XDECREF_SET(__pyx_v_future_asteroid_during_imminent_collision_time, __pyx_t_12);
            __pyx_t_12 = 0;
          }
          __pyx_L18:;

 3726:                         # if self.sim_id == 13974:

 3727:                         # print(f"Getting extrapolated next coll time for unwrapped asteroid {ast_to_string(a)}. Initial TS: {self.initial_timestep}, future TS: {self.future_timesteps}, additional timesteps to blow up mines: {additional_timesteps_to_blow_up_mines}, predicted collision additional ts: {predicted_collision_ts}")

 3728:                         # print(self.asteroids_pending_death)

+3729:                         if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + predicted_collision_ts, self.game_state, future_asteroid_during_imminent_collision_time):

          __pyx_t_22 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_24, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_24);
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_20 = PyNumber_Add(__pyx_t_23, __pyx_t_25); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __pyx_t_25 = PyNumber_Add(__pyx_t_20, __pyx_v_predicted_collision_ts); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_24))) {
            __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_24);
            assert(__pyx_t_22);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_24);
            __Pyx_INCREF(__pyx_t_22);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_24, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[5] = {__pyx_t_22, __pyx_t_2, __pyx_t_25, __pyx_t_20, __pyx_v_future_asteroid_during_imminent_collision_time};
            __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_24, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
            if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3729, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_12);
          }
          __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3729, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          if (__pyx_t_14) {
/* … */
          }

 3730:                             # In the future time the asteroid has already been eliminated, so there won't actually be a collision

 3731:                             # debug_print("In the future time the asteroid has already been eliminated, so there won't actually be a collision")

+3732:                             continue

            goto __pyx_L5_continue;

 3733:                         else:

+3734:                             next_imminent_asteroid_collision_time = min(next_imminent_asteroid_collision_time, predicted_collision_time)

          /*else*/ {
            __Pyx_INCREF(__pyx_v_predicted_collision_time);
            __pyx_t_12 = __pyx_v_predicted_collision_time;
            __Pyx_INCREF(__pyx_v_next_imminent_asteroid_collision_time);
            __pyx_t_24 = __pyx_v_next_imminent_asteroid_collision_time;
            __pyx_t_25 = PyObject_RichCompare(__pyx_t_12, __pyx_t_24, Py_LT); __Pyx_XGOTREF(__pyx_t_25); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3734, __pyx_L1_error)
            __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3734, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
            if (__pyx_t_14) {
              __Pyx_INCREF(__pyx_t_12);
              __pyx_t_20 = __pyx_t_12;
            } else {
              __Pyx_INCREF(__pyx_t_24);
              __pyx_t_20 = __pyx_t_24;
            }
            __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
            __pyx_t_12 = __pyx_t_20;
            __Pyx_INCREF(__pyx_t_12);
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __Pyx_DECREF_SET(__pyx_v_next_imminent_asteroid_collision_time, __pyx_t_12);
            __pyx_t_12 = 0;
          }

 3735:                     else:

 3736:                         # We're not eliminating this asteroid, and if it was forecasted, it comes into existence before our collision time. Therefore our collision is real and should be considered.

+3737:                         next_imminent_asteroid_collision_time = min(next_imminent_asteroid_collision_time, predicted_collision_time)

        /*else*/ {
          __Pyx_INCREF(__pyx_v_predicted_collision_time);
          __pyx_t_12 = __pyx_v_predicted_collision_time;
          __Pyx_INCREF(__pyx_v_next_imminent_asteroid_collision_time);
          __pyx_t_20 = __pyx_v_next_imminent_asteroid_collision_time;
          __pyx_t_25 = PyObject_RichCompare(__pyx_t_12, __pyx_t_20, Py_LT); __Pyx_XGOTREF(__pyx_t_25); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 3737, __pyx_L1_error)
          __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 3737, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          if (__pyx_t_14) {
            __Pyx_INCREF(__pyx_t_12);
            __pyx_t_24 = __pyx_t_12;
          } else {
            __Pyx_INCREF(__pyx_t_20);
            __pyx_t_24 = __pyx_t_20;
          }
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          __pyx_t_12 = __pyx_t_24;
          __Pyx_INCREF(__pyx_t_12);
          __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
          __Pyx_DECREF_SET(__pyx_v_next_imminent_asteroid_collision_time, __pyx_t_12);
          __pyx_t_12 = 0;
        }
        __pyx_L17:;

 3738:                 #else:

 3739:                     # There is no collision since the asteroid is born after our predicted collision time, and an unborn asteroid can't collide with anything

 3740:                     # debug_print("There is no collision since the unborn asteroid can't collide with anything")

 3741:                 #    pass

 3742:             # else:

 3743:             #    debug_print(f"Inside extrapolated coll time checker. We already have a pending shot for this so we'll ignore this asteroid: {ast_to_string(asteroid)}")

+3744:         return next_imminent_asteroid_collision_time

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_next_imminent_asteroid_collision_time);
  __pyx_r = __pyx_v_next_imminent_asteroid_collision_time;
  goto __pyx_L0;

 3745: 

+3746:     def get_next_extrapolated_mine_collision_times_and_pos(self) -> list[tuple[float, tuple[float, float]]]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_37get_next_extrapolated_mine_collision_times_and_pos(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_37get_next_extrapolated_mine_collision_times_and_pos = {"get_next_extrapolated_mine_collision_times_and_pos", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_37get_next_extrapolated_mine_collision_times_and_pos, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_37get_next_extrapolated_mine_collision_times_and_pos(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_next_extrapolated_mine_collision_times_and_pos (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3746, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3746, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_next_extrapolated_mine_collision_times_and_pos", 0) < 0) __PYX_ERR(0, 3746, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_next_extrapolated_mine_collision_times_and_pos", 1, 1, 1, i); __PYX_ERR(0, 3746, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3746, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_next_extrapolated_mine_collision_times_and_pos", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3746, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_next_extrapolated_mine_collision_times_and_pos", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_36get_next_extrapolated_mine_collision_times_and_pos(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_36get_next_extrapolated_mine_collision_times_and_pos(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_times_and_mine_pos = NULL;
  PyObject *__pyx_v_m = NULL;
  PyObject *__pyx_v_next_imminent_mine_collision_time = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.Matrix.get_next_extrapolated_mine_collision_times_and_pos", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_times_and_mine_pos);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XDECREF(__pyx_v_next_imminent_mine_collision_time);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3746, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_tuple_float_tuple_float_flo) < 0) __PYX_ERR(0, 3746, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_37get_next_extrapolated_mine_collision_times_and_pos, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_next_extrapolated_min, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[164])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3746, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_next_extrapolated_mine_colli, __pyx_t_3) < 0) __PYX_ERR(0, 3746, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
struct __pyx_ctuple_142d2d__double__and_14neo_controller__dunder_pyx_ctupl__etc {
  double f0;
  __pyx_ctuple_double__and_double f1;
};

+3747:         times_and_mine_pos = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3747, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_times_and_mine_pos = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+3748:         for m in self.game_state.mines:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3748, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3748, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3748, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3748, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3748, __pyx_L1_error)
          #endif
          if (__pyx_t_3 >= __pyx_temp) break;
        }
        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_3);
        ++__pyx_t_3;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3748, __pyx_L1_error)
          #endif
          if (__pyx_t_3 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3));
        #else
        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_3);
        #endif
        ++__pyx_t_3;
      }
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3748, __pyx_L1_error)
    } else {
      __pyx_t_2 = __pyx_t_4(__pyx_t_1);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3748, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 3749:             # print(f"{self.ship_state.velocity=}")

+3750:             next_imminent_mine_collision_time = predict_ship_mine_collision(self.ship_state.position[0], self.ship_state.position[1], m, 0)

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_predict_ship_mine_collision); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[5] = {__pyx_t_5, __pyx_t_7, __pyx_t_8, __pyx_v_m, __pyx_mstate_global->__pyx_int_0};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3750, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_XDECREF_SET(__pyx_v_next_imminent_mine_collision_time, __pyx_t_2);
    __pyx_t_2 = 0;

+3751:             if not isinf(next_imminent_mine_collision_time):

    __pyx_t_11 = __Pyx_PyFloat_AsDouble(__pyx_v_next_imminent_mine_collision_time); if (unlikely((__pyx_t_11 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3751, __pyx_L1_error)
    __pyx_t_12 = (!(isinf(__pyx_t_11) != 0));
    if (__pyx_t_12) {
/* … */
    }

+3752:                 times_and_mine_pos.append((next_imminent_mine_collision_time, m.position))

      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3752, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3752, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_INCREF(__pyx_v_next_imminent_mine_collision_time);
      __Pyx_GIVEREF(__pyx_v_next_imminent_mine_collision_time);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_next_imminent_mine_collision_time) != (0)) __PYX_ERR(0, 3752, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_2);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 3752, __pyx_L1_error);
      __pyx_t_2 = 0;
      __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_times_and_mine_pos, __pyx_t_6); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(0, 3752, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+3753:         return times_and_mine_pos

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_times_and_mine_pos);
  __pyx_r = __pyx_v_times_and_mine_pos;
  goto __pyx_L0;

 3754: 

+3755:     def coordinates_in_same_wrap(self, pos1: tuple[float, float], pos2: tuple[float, float]) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_39coordinates_in_same_wrap(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_39coordinates_in_same_wrap = {"coordinates_in_same_wrap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_39coordinates_in_same_wrap, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_39coordinates_in_same_wrap(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  __pyx_ctuple_double__and_double __pyx_v_pos1;
  __pyx_ctuple_double__and_double __pyx_v_pos2;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("coordinates_in_same_wrap (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_pos1,&__pyx_mstate_global->__pyx_n_u_pos2,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3755, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3755, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3755, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3755, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "coordinates_in_same_wrap", 0) < 0) __PYX_ERR(0, 3755, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("coordinates_in_same_wrap", 1, 3, 3, i); __PYX_ERR(0, 3755, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3755, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3755, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3755, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_pos1 = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3755, __pyx_L3_error)
    __pyx_v_pos2 = __pyx_convert__from_py___pyx_ctuple_double__and_double(values[2]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3755, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("coordinates_in_same_wrap", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3755, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.coordinates_in_same_wrap", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_38coordinates_in_same_wrap(__pyx_self, __pyx_v_self, __pyx_v_pos1, __pyx_v_pos2);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_38coordinates_in_same_wrap(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, __pyx_ctuple_double__and_double __pyx_v_pos1, __pyx_ctuple_double__and_double __pyx_v_pos2) {
  PyObject *__pyx_v_max_width = NULL;
  PyObject *__pyx_v_max_height = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.Matrix.coordinates_in_same_wrap", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_max_width);
  __Pyx_XDECREF(__pyx_v_max_height);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pos1, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 3755, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pos2, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 3755, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 3755, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_39coordinates_in_same_wrap, 0, __pyx_mstate_global->__pyx_n_u_Matrix_coordinates_in_same_wrap, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[165])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_coordinates_in_same_wrap, __pyx_t_2) < 0) __PYX_ERR(0, 3755, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 3756:         # UNUSED

 3757:         # Checks whether the coordinates are in the same universe

+3758:         max_width = self.game_state.map_size[0]

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3758, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3758, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3758, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_max_width = __pyx_t_1;
  __pyx_t_1 = 0;

+3759:         max_height = self.game_state.map_size[1]

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3759, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3759, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3759, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_max_height = __pyx_t_1;
  __pyx_t_1 = 0;

 3760:         # TODO: Honestly this is kinda sketch and using modulo is probably more accurate.

+3761:         return bool(pos1[0]//max_width == pos2[0]//max_width and pos1[1]//max_height == pos2[1]//max_height)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pos1.f0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_FloorDivide(__pyx_t_1, __pyx_v_max_width); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pos2.f0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_FloorDivide(__pyx_t_1, __pyx_v_max_width); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_5) {
  } else {
    __pyx_t_3 = __pyx_t_5;
    goto __pyx_L3_bool_binop_done;
  }
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pos1.f1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyNumber_FloorDivide(__pyx_t_1, __pyx_v_max_height); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pos2.f1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyNumber_FloorDivide(__pyx_t_1, __pyx_v_max_height); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __pyx_t_5;
  __pyx_L3_bool_binop_done:;
  __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_3))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 3762: 

+3763:     def get_fitness(self) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_41get_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_41get_fitness = {"get_fitness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_41get_fitness, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_41get_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_fitness (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3763, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3763, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_fitness", 0) < 0) __PYX_ERR(0, 3763, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_fitness", 1, 1, 1, i); __PYX_ERR(0, 3763, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3763, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_fitness", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3763, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_40get_fitness(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_6Matrix_40get_fitness(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_cur_scope;
  PyObject *__pyx_v_get_asteroid_safe_time_fitness = 0;
  PyObject *__pyx_v_get_asteroid_shot_frequency_fitness = 0;
  PyObject *__pyx_v_get_mine_safety_fitness = 0;
  PyObject *__pyx_v_get_asteroid_aiming_cone_fitness = 0;
  PyObject *__pyx_v_get_crash_fitness = 0;
  PyObject *__pyx_v_get_sequence_length_fitness = 0;
  PyObject *__pyx_v_get_other_ship_proximity_fitness = 0;
  PyObject *__pyx_v_states = NULL;
  PyObject *__pyx_v_move_sequence_length_s = NULL;
  PyObject *__pyx_v_next_extrapolated_mine_collision_times = NULL;
  PyObject *__pyx_v_mine_safe_time_fitness = NULL;
  PyObject *__pyx_v_next_extrapolated_mine_collision_time = NULL;
  PyObject *__pyx_v_asteroids_fitness = NULL;
  PyObject *__pyx_v_asteroid_aiming_cone_fitness = NULL;
  PyObject *__pyx_v_additional_timesteps_to_blow_up_mines = NULL;
  PyObject *__pyx_v_next_extrapolated_asteroid_collision_time = NULL;
  PyObject *__pyx_v_safe_time_after_maneuver_s = NULL;
  PyObject *__pyx_v_next_extrapolated_asteroid_collision_time_after_mines = NULL;
  PyObject *__pyx_v_overall_safe_time_fitness = NULL;
  PyObject *__pyx_v_ship_start_position = NULL;
  PyObject *__pyx_v_ship_end_position = NULL;
  PyObject *__pyx_v_displacement = NULL;
  PyObject *__pyx_v_asteroid_safe_time_fitness = NULL;
  PyObject *__pyx_v_self_ship_positions = NULL;
  PyObject *__pyx_v_other_ship_proximity_fitness = NULL;
  PyObject *__pyx_v_sequence_length_fitness = NULL;
  PyObject *__pyx_v_crash_fitness = NULL;
  PyObject *__pyx_v_placed_mine_fitness = NULL;
  PyObject *__pyx_v_fitness_breakdown = NULL;
  PyObject *__pyx_v_fitness_weights = NULL;
  PyObject *__pyx_v_overall_fitness = NULL;
  PyObject *__pyx_9genexpr29__pyx_v_a = NULL;
  PyObject *__pyx_9genexpr30__pyx_v_m = NULL;
  PyObject *__pyx_9genexpr31__pyx_v_b = NULL;
  PyObject *__pyx_9genexpr32__pyx_v_s = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *)__pyx_tp_new_14neo_controller___pyx_scope_struct_12_get_fitness(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_12_get_fitness, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 3763, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_self = __pyx_v_self;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_get_asteroid_safe_time_fitness);
  __Pyx_XDECREF(__pyx_v_get_asteroid_shot_frequency_fitness);
  __Pyx_XDECREF(__pyx_v_get_mine_safety_fitness);
  __Pyx_XDECREF(__pyx_v_get_asteroid_aiming_cone_fitness);
  __Pyx_XDECREF(__pyx_v_get_crash_fitness);
  __Pyx_XDECREF(__pyx_v_get_sequence_length_fitness);
  __Pyx_XDECREF(__pyx_v_get_other_ship_proximity_fitness);
  __Pyx_XDECREF(__pyx_v_states);
  __Pyx_XDECREF(__pyx_v_move_sequence_length_s);
  __Pyx_XDECREF(__pyx_v_next_extrapolated_mine_collision_times);
  __Pyx_XDECREF(__pyx_v_mine_safe_time_fitness);
  __Pyx_XDECREF(__pyx_v_next_extrapolated_mine_collision_time);
  __Pyx_XDECREF(__pyx_v_asteroids_fitness);
  __Pyx_XDECREF(__pyx_v_asteroid_aiming_cone_fitness);
  __Pyx_XDECREF(__pyx_v_additional_timesteps_to_blow_up_mines);
  __Pyx_XDECREF(__pyx_v_next_extrapolated_asteroid_collision_time);
  __Pyx_XDECREF(__pyx_v_safe_time_after_maneuver_s);
  __Pyx_XDECREF(__pyx_v_next_extrapolated_asteroid_collision_time_after_mines);
  __Pyx_XDECREF(__pyx_v_overall_safe_time_fitness);
  __Pyx_XDECREF(__pyx_v_ship_start_position);
  __Pyx_XDECREF(__pyx_v_ship_end_position);
  __Pyx_XDECREF(__pyx_v_displacement);
  __Pyx_XDECREF(__pyx_v_asteroid_safe_time_fitness);
  __Pyx_XDECREF(__pyx_v_self_ship_positions);
  __Pyx_XDECREF(__pyx_v_other_ship_proximity_fitness);
  __Pyx_XDECREF(__pyx_v_sequence_length_fitness);
  __Pyx_XDECREF(__pyx_v_crash_fitness);
  __Pyx_XDECREF(__pyx_v_placed_mine_fitness);
  __Pyx_XDECREF(__pyx_v_fitness_breakdown);
  __Pyx_XDECREF(__pyx_v_fitness_weights);
  __Pyx_XDECREF(__pyx_v_overall_fitness);
  __Pyx_XDECREF(__pyx_9genexpr29__pyx_v_a);
  __Pyx_XDECREF(__pyx_9genexpr30__pyx_v_m);
  __Pyx_XDECREF(__pyx_9genexpr31__pyx_v_b);
  __Pyx_XDECREF(__pyx_9genexpr32__pyx_v_s);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3763, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_41get_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[166])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_fitness, __pyx_t_3) < 0) __PYX_ERR(0, 3763, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness {
  PyObject_HEAD
  PyObject *__pyx_v_self;
};

 3764:         #if self.sim_id in [15869, 73186]:

 3765:         #    print(f"Getting fitness in sim id {self.sim_id} and the move sequence is:", self.get_move_sequence(), 'and the ship state is:', self.get_ship_state(), 'and the ship crashed is', self.ship_crashed)

+3766:         if self.fitness_breakdown:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3766, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+3767:             raise Exception("Do not call get_fitness twice!")

    __pyx_t_3 = NULL;
    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Do_not_call_get_fitness_twice};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3767, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 3767, __pyx_L1_error)

 3768:         # This is meant to be the last method called from this class. This is rather destructive!

 3769:         # print(f"Getting fitness from timestep {self.initial_timestep=} {self.future_timesteps=} in sim id {self.sim_id}")

+3770:         assert is_close_to_zero(self.ship_state.speed), f"In get fitness, the ship speed is not zero: {self.ship_state.speed}, vel is {self.ship_state.velocity}, current ts is {self.initial_timestep + self.future_timesteps} and the time limit is {self.game_state.time_limit} which is {floor(FPS*self.game_state.time_limit)} frames"  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3770, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3770, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3770, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3770, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) {
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = PyNumber_Add(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyNumber_Multiply(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_10, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_In_get_fitness_the_ship_speed_is;
      __pyx_t_11[1] = __pyx_t_1;
      __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_vel_is;
      __pyx_t_11[3] = __pyx_t_3;
      __pyx_t_11[4] = __pyx_mstate_global->__pyx_kp_u_current_ts_is;
      __pyx_t_11[5] = __pyx_t_4;
      __pyx_t_11[6] = __pyx_mstate_global->__pyx_kp_u_and_the_time_limit_is;
      __pyx_t_11[7] = __pyx_t_6;
      __pyx_t_11[8] = __pyx_mstate_global->__pyx_kp_u_which_is;
      __pyx_t_11[9] = __pyx_t_9;
      __pyx_t_11[10] = __pyx_mstate_global->__pyx_kp_u_frames;
      __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_11, 11, 44 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 9 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 16 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 23 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 7, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3770, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_10, 0, 0);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __PYX_ERR(0, 3770, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 3770, __pyx_L1_error)
  #endif

 3771:         # This will return a scalar number representing how good of an action/state sequence we just went through

 3772:         # If these moves will keep us alive for a long time and shoot many asteroids along the way, then the fitness is good

 3773:         # If these moves result in us getting into a dangerous spot, or if we don't shoot many asteroids at all, then the fitness will be bad

 3774:         # The HIGHER the fitness score, the BETTER!

 3775:         # This fitness function is unified to consider all three types of moves. Stationary targeting, maneuvers, and respawn maneuvers.

 3776: 

+3777:         def get_asteroid_safe_time_fitness(next_extrapolated_asteroid_collision_time: float, displacement: float, move_sequence_length_s: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_1get_asteroid_safe_time_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_fitness_1get_asteroid_safe_time_fitness = {"get_asteroid_safe_time_fitness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_11get_fitness_1get_asteroid_safe_time_fitness, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_1get_asteroid_safe_time_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_next_extrapolated_asteroid_collision_time;
  double __pyx_v_displacement;
  double __pyx_v_move_sequence_length_s;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_asteroid_safe_time_fitness (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_next_extrapolated_asteroid_colli,&__pyx_mstate_global->__pyx_n_u_displacement,&__pyx_mstate_global->__pyx_n_u_move_sequence_length_s,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3777, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3777, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3777, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3777, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_asteroid_safe_time_fitness", 0) < 0) __PYX_ERR(0, 3777, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_asteroid_safe_time_fitness", 1, 3, 3, i); __PYX_ERR(0, 3777, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3777, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3777, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3777, __pyx_L3_error)
    }
    __pyx_v_next_extrapolated_asteroid_collision_time = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_next_extrapolated_asteroid_collision_time == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3777, __pyx_L3_error)
    __pyx_v_displacement = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_displacement == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3777, __pyx_L3_error)
    __pyx_v_move_sequence_length_s = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_move_sequence_length_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3777, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_asteroid_safe_time_fitness", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3777, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_asteroid_safe_time_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_11get_fitness_get_asteroid_safe_time_fitness(__pyx_self, __pyx_v_next_extrapolated_asteroid_collision_time, __pyx_v_displacement, __pyx_v_move_sequence_length_s);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_11get_fitness_get_asteroid_safe_time_fitness(PyObject *__pyx_self, double __pyx_v_next_extrapolated_asteroid_collision_time, double __pyx_v_displacement, double __pyx_v_move_sequence_length_s) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_outer_scope;
  PyObject *__pyx_v_asteroid_safe_time_fitness = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_asteroid_safe_time_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_asteroid_safe_time_fitness);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_10 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3777, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_next_extrapolated_asteroid_colli, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3777, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_displacement, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3777, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_move_sequence_length_s, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3777, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3777, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_fitness_1get_asteroid_safe_time_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_locals_get_as, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3777, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_10);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_get_asteroid_safe_time_fitness = __pyx_t_9;
  __pyx_t_9 = 0;

 3778:             # NOTE THAT the move sequence length is discounted, because if we're deciding between maneuvers, we really mostly care about how long you're safe for after the maneuver is done!

+3779:             if not isinf(self.game_state.time_limit) and self.initial_timestep + self.future_timesteps + END_OF_SCENARIO_DONT_CARE_TIMESTEPS >= floor(FPS*self.game_state.time_limit):

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3779, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = (!(isinf(__pyx_t_4) != 0));
  if (__pyx_t_5) {
  } else {
    __pyx_t_1 = __pyx_t_5;
    goto __pyx_L4_bool_binop_done;
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3779, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3779, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_END_OF_SCENARIO_DONT_CARE_TIMEST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3779, __pyx_L1_error) }
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = PyNumber_Multiply(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3779, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3779, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_1 = __pyx_t_5;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 3780:                 # The scenario is done! We don't care about the future past the end of time!

+3781:                 return 1.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_1_0;
    goto __pyx_L0;

+3782:             elif self.ship_state.bullets_remaining == 0 and self.ship_state.mines_remaining == 0:

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3782, __pyx_L1_error) }
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3782, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_5) {
  } else {
    __pyx_t_1 = __pyx_t_5;
    goto __pyx_L6_bool_binop_done;
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3782, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3782, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3782, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_1 = __pyx_t_5;
  __pyx_L6_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 3783:                 # We stop caring at this point!

+3784:                 return 1.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_1_0;
    goto __pyx_L0;

 3785:             else:

+3786:                 if displacement < EPS:

  /*else*/ {
    __pyx_t_1 = (__pyx_v_displacement < __pyx_v_14neo_controller_EPS);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L8;
    }

 3787:                     # Stationary

 3788:                     # TODO: See whether there's something wrong with counting the move sequence length in this. It might be fine to count it all, or maybe use a discount factor

 3789:                     # Only has to be safe for 4 seconds to get the max score, to encourage staying put and eliminating threats by shooting rather than by maneuvering and missing shot opportunities

 3790:                     # asteroid_safe_time_fitness = max(0, min(5, 5 - 5/4*next_extrapolated_asteroid_collision_time)) # Goes through (0, 0) (4, 1) SCRATCH THIS

+3791:                     asteroid_safe_time_fitness = sigmoid(next_extrapolated_asteroid_collision_time + move_sequence_length_s*0.25, 1.4, 3.0)  # sigmoid(next_extrapolated_asteroid_collision_time, 2.1*4/5, 2.5)

      __pyx_t_2 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3791, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = PyFloat_FromDouble((__pyx_v_next_extrapolated_asteroid_collision_time + (__pyx_v_move_sequence_length_s * 0.25))); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3791, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_2);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_t_9, __pyx_mstate_global->__pyx_float_1_4, __pyx_mstate_global->__pyx_float_3_0};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3791, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __pyx_v_asteroid_safe_time_fitness = __pyx_t_7;
      __pyx_t_7 = 0;

 3792:                 else:

 3793:                     # Maneuvering

 3794:                     # asteroid_safe_time_fitness = max(0, min(5, 5 - next_extrapolated_asteroid_collision_time)) # Goes through (0, 0) (5, 1) SCRATCH THIS

+3795:                     asteroid_safe_time_fitness = sigmoid(next_extrapolated_asteroid_collision_time + move_sequence_length_s*0.25, 1.4, 3.0)

    /*else*/ {
      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3795, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_2 = PyFloat_FromDouble((__pyx_v_next_extrapolated_asteroid_collision_time + (__pyx_v_move_sequence_length_s * 0.25))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3795, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_t_2, __pyx_mstate_global->__pyx_float_1_4, __pyx_mstate_global->__pyx_float_3_0};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3795, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __pyx_v_asteroid_safe_time_fitness = __pyx_t_7;
      __pyx_t_7 = 0;
    }
    __pyx_L8:;
  }

+3796:             return asteroid_safe_time_fitness

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_asteroid_safe_time_fitness);
  __pyx_r = __pyx_v_asteroid_safe_time_fitness;
  goto __pyx_L0;

 3797: 

+3798:         def get_asteroid_shot_frequency_fitness(asteroids_shot: int, move_sequence_length_s: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_3get_asteroid_shot_frequency_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_fitness_3get_asteroid_shot_frequency_fitness = {"get_asteroid_shot_frequency_fitness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_11get_fitness_3get_asteroid_shot_frequency_fitness, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_3get_asteroid_shot_frequency_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_asteroids_shot = 0;
  double __pyx_v_move_sequence_length_s;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_asteroid_shot_frequency_fitness (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_asteroids_shot,&__pyx_mstate_global->__pyx_n_u_move_sequence_length_s,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3798, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3798, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3798, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_asteroid_shot_frequency_fitness", 0) < 0) __PYX_ERR(0, 3798, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_asteroid_shot_frequency_fitness", 1, 2, 2, i); __PYX_ERR(0, 3798, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3798, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3798, __pyx_L3_error)
    }
    __pyx_v_asteroids_shot = ((PyObject*)values[0]);
    __pyx_v_move_sequence_length_s = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_move_sequence_length_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3798, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_asteroid_shot_frequency_fitness", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3798, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_asteroid_shot_frequency_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids_shot), (&PyLong_Type), 0, "asteroids_shot", 2))) __PYX_ERR(0, 3798, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_11get_fitness_2get_asteroid_shot_frequency_fitness(__pyx_self, __pyx_v_asteroids_shot, __pyx_v_move_sequence_length_s);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_11get_fitness_2get_asteroid_shot_frequency_fitness(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_asteroids_shot, double __pyx_v_move_sequence_length_s) {
  double __pyx_v_fudged_asteroids_shot;
  double __pyx_v_time_per_asteroids_shot;
  PyObject *__pyx_v_asteroids_fitness = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_asteroid_shot_frequency_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_asteroids_fitness);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3798, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 3798, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_move_sequence_length_s, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3798, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3798, __pyx_L1_error)
  __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_fitness_3get_asteroid_shot_frequency_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_locals_get_as_2, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3798, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_10, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_v_get_asteroid_shot_frequency_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

 3799:             # How many asteroids did we shoot? The more the better.

+3800:             if asteroids_shot < 0:

  __pyx_t_1 = PyObject_RichCompare(__pyx_v_asteroids_shot, __pyx_mstate_global->__pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3800, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3800, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

 3801:                 # This is to signal that we won't hit anything ever if we're staying here, so we should defer to the maneuver subcontroller to force a move

 3802:                 # This is less effective with this new fitness system, but it should still work eventually.

 3803:                 # debug_print(f"Deferring to maneuver subcontroller! Forcing a move.")

+3804:                 return -0.9

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_0_9);
    __pyx_r = __pyx_mstate_global->__pyx_float_neg_0_9;
    goto __pyx_L0;

 3805:             else:

+3806:                 fudged_asteroids_shot: float

  /*else*/ {

+3807:                 if asteroids_shot == 0:

    __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_asteroids_shot, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3807, __pyx_L1_error)
    if (__pyx_t_2) {
/* … */
      goto __pyx_L4;
    }

+3808:                     fudged_asteroids_shot = 0.1  # Avoid division by zero

      __pyx_v_fudged_asteroids_shot = 0.1;

 3809:                 else:

+3810:                     fudged_asteroids_shot = float(asteroids_shot)

    /*else*/ {
      __pyx_t_3 = PyLong_AsDouble(__pyx_v_asteroids_shot); if (unlikely(__pyx_t_3 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3810, __pyx_L1_error)
      __pyx_v_fudged_asteroids_shot = __pyx_t_3;
    }
    __pyx_L4:;

+3811:                 time_per_asteroids_shot = move_sequence_length_s/fudged_asteroids_shot

    if (unlikely(__pyx_v_fudged_asteroids_shot == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 3811, __pyx_L1_error)
    }
    __pyx_v_time_per_asteroids_shot = (__pyx_v_move_sequence_length_s / __pyx_v_fudged_asteroids_shot);

 3812: 

 3813:                 # Applying the sigmoid function to smooth the transition

+3814:                 asteroids_fitness = sigmoid(time_per_asteroids_shot, -0.5*FPS, 10.8*DELTA_TIME)

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_time_per_asteroids_shot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_neg_0_5, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_10_8, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_t_6, __pyx_t_8, __pyx_t_9};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3814, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_asteroids_fitness = __pyx_t_1;
    __pyx_t_1 = 0;
  }

+3815:             return asteroids_fitness

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_asteroids_fitness);
  __pyx_r = __pyx_v_asteroids_fitness;
  goto __pyx_L0;

 3816: 

+3817:         def get_mine_safety_fitness(next_extrapolated_mine_collision_times: list[tuple[float, tuple[float, float]]]) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_5get_mine_safety_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_fitness_5get_mine_safety_fitness = {"get_mine_safety_fitness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_11get_fitness_5get_mine_safety_fitness, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_5get_mine_safety_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_next_extrapolated_mine_collision_times = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_mine_safety_fitness (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_next_extrapolated_mine_collision,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3817, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3817, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_mine_safety_fitness", 0) < 0) __PYX_ERR(0, 3817, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_mine_safety_fitness", 1, 1, 1, i); __PYX_ERR(0, 3817, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3817, __pyx_L3_error)
    }
    __pyx_v_next_extrapolated_mine_collision_times = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_mine_safety_fitness", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3817, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_mine_safety_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_next_extrapolated_mine_collision_times), (&PyList_Type), 0, "next_extrapolated_mine_collision_times", 2))) __PYX_ERR(0, 3817, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_11get_fitness_4get_mine_safety_fitness(__pyx_self, __pyx_v_next_extrapolated_mine_collision_times);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_11get_fitness_4get_mine_safety_fitness(PyObject *__pyx_self, PyObject *__pyx_v_next_extrapolated_mine_collision_times) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_outer_scope;
  PyObject *__pyx_v_mines_threat_level = NULL;
  PyObject *__pyx_v_next_extrapolated_mine_collision_time = NULL;
  PyObject *__pyx_v_mine_collision_time = NULL;
  PyObject *__pyx_v_mine_pos = NULL;
  PyObject *__pyx_v_dist_to_ground_zero = NULL;
  PyObject *__pyx_v_mine_ground_zero_fudge = NULL;
  PyObject *__pyx_v_mine_safe_time_fitness = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_mine_safety_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mines_threat_level);
  __Pyx_XDECREF(__pyx_v_next_extrapolated_mine_collision_time);
  __Pyx_XDECREF(__pyx_v_mine_collision_time);
  __Pyx_XDECREF(__pyx_v_mine_pos);
  __Pyx_XDECREF(__pyx_v_dist_to_ground_zero);
  __Pyx_XDECREF(__pyx_v_mine_ground_zero_fudge);
  __Pyx_XDECREF(__pyx_v_mine_safe_time_fitness);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3817, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_next_extrapolated_mine_collision, __pyx_mstate_global->__pyx_kp_u_list_tuple_float_tuple_float_flo) < 0) __PYX_ERR(0, 3817, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 3817, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_fitness_5get_mine_safety_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_locals_get_mi, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3817, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_10);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_get_mine_safety_fitness = __pyx_t_9;
  __pyx_t_9 = 0;

 3818:             # If there's no mine in the final ship position's range, the fitness is perfect.

 3819:             # For each additional mine within the range, the fitness will go down.

 3820:             # Having two mines which are freshly placed isn't as bad as a single mine that's about to blow up.

 3821:             # For each mine, as the time goes down, the danger should go up more than linearly

+3822:             if not next_extrapolated_mine_collision_times:

  __pyx_t_1 = (__Pyx_PyList_GET_SIZE(__pyx_v_next_extrapolated_mine_collision_times) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 3822, __pyx_L1_error)
  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+3823:                 return 1.0, INFINITY

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3823, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3823, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_1_0);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_float_1_0) != (0)) __PYX_ERR(0, 3823, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 3823, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

+3824:             if not isinf(self.game_state.time_limit) and self.initial_timestep + self.future_timesteps + END_OF_SCENARIO_DONT_CARE_TIMESTEPS >= floor(FPS*self.game_state.time_limit):

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3824, __pyx_L1_error) }
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_5 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = (!(isinf(__pyx_t_5) != 0));
  if (__pyx_t_1) {
  } else {
    __pyx_t_2 = __pyx_t_1;
    goto __pyx_L5_bool_binop_done;
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3824, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3824, __pyx_L1_error) }
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_END_OF_SCENARIO_DONT_CARE_TIMEST); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyNumber_Add(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3824, __pyx_L1_error) }
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = PyNumber_Multiply(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3824, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3824, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_2 = __pyx_t_1;
  __pyx_L5_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

 3825:                 # The scenario's done so we don't care about mine safety past the end of time!

+3826:                 return 1.0, INFINITY

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_7 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_1_0);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_float_1_0) != (0)) __PYX_ERR(0, 3826, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_7);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 3826, __pyx_L1_error);
    __pyx_t_7 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 3827:             # Regardless of stationary or maneuvering, the mine safe time score is calculated the same way

+3828:             mines_threat_level = 0.0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
  __pyx_v_mines_threat_level = __pyx_mstate_global->__pyx_float_0_0;

+3829:             next_extrapolated_mine_collision_time = INFINITY

  __pyx_t_4 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_v_next_extrapolated_mine_collision_time = __pyx_t_4;
  __pyx_t_4 = 0;

+3830:             if next_extrapolated_mine_collision_times:

  __pyx_t_2 = (__Pyx_PyList_GET_SIZE(__pyx_v_next_extrapolated_mine_collision_times) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_2 < 0))) __PYX_ERR(0, 3830, __pyx_L1_error)
  if (__pyx_t_2) {
/* … */
  }

+3831:                 for mine_collision_time, mine_pos in next_extrapolated_mine_collision_times:

    __pyx_t_4 = __pyx_v_next_extrapolated_mine_collision_times; __Pyx_INCREF(__pyx_t_4);
    __pyx_t_12 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3831, __pyx_L1_error)
        #endif
        if (__pyx_t_12 >= __pyx_temp) break;
      }
      __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_12);
      ++__pyx_t_12;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3831, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
        PyObject* sequence = __pyx_t_7;
        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
        if (unlikely(size != 2)) {
          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
          __PYX_ERR(0, 3831, __pyx_L1_error)
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        if (likely(PyTuple_CheckExact(sequence))) {
          __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
          __Pyx_INCREF(__pyx_t_3);
          __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1);
          __Pyx_INCREF(__pyx_t_9);
        } else {
          __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 0);
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3831, __pyx_L1_error)
          __Pyx_XGOTREF(__pyx_t_3);
          __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 1);
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3831, __pyx_L1_error)
          __Pyx_XGOTREF(__pyx_t_9);
        }
        #else
        __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3831, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3831, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        #endif
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      } else {
        Py_ssize_t index = -1;
        __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3831, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6);
        index = 0; __pyx_t_3 = __pyx_t_13(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L10_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_3);
        index = 1; __pyx_t_9 = __pyx_t_13(__pyx_t_6); if (unlikely(!__pyx_t_9)) goto __pyx_L10_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_9);
        if (__Pyx_IternextUnpackEndCheck(__pyx_t_13(__pyx_t_6), 2) < 0) __PYX_ERR(0, 3831, __pyx_L1_error)
        __pyx_t_13 = NULL;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        goto __pyx_L11_unpacking_done;
        __pyx_L10_unpacking_failed:;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_13 = NULL;
        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
        __PYX_ERR(0, 3831, __pyx_L1_error)
        __pyx_L11_unpacking_done:;
      }
      __Pyx_XDECREF_SET(__pyx_v_mine_collision_time, __pyx_t_3);
      __pyx_t_3 = 0;
      __Pyx_XDECREF_SET(__pyx_v_mine_pos, __pyx_t_9);
      __pyx_t_9 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+3832:                     next_extrapolated_mine_collision_time = min(next_extrapolated_mine_collision_time, mine_collision_time)

      __Pyx_INCREF(__pyx_v_mine_collision_time);
      __pyx_t_7 = __pyx_v_mine_collision_time;
      __Pyx_INCREF(__pyx_v_next_extrapolated_mine_collision_time);
      __pyx_t_9 = __pyx_v_next_extrapolated_mine_collision_time;
      __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_t_9, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3832, __pyx_L1_error)
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3832, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (__pyx_t_2) {
        __Pyx_INCREF(__pyx_t_7);
        __pyx_t_3 = __pyx_t_7;
      } else {
        __Pyx_INCREF(__pyx_t_9);
        __pyx_t_3 = __pyx_t_9;
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __pyx_t_3;
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF_SET(__pyx_v_next_extrapolated_mine_collision_time, __pyx_t_7);
      __pyx_t_7 = 0;

 3833:                     # next_extrapolated_mine_collision_time = max(0, min(3, next_extrapolated_mine_collision_time))

+3834:                     if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3834, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3834, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (__pyx_t_2) {
/* … */
      }

+3835:                         assert -EPS <= mine_collision_time <= MINE_FUSE_TIME + EPS  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_7 = PyFloat_FromDouble((-__pyx_v_14neo_controller_EPS)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3835, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_v_mine_collision_time, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3835, __pyx_L1_error)
          if (__Pyx_PyObject_IsTrue(__pyx_t_3)) {
            __Pyx_DECREF(__pyx_t_3);
            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3835, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_6 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3835, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            __pyx_t_10 = PyNumber_Add(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3835, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            __pyx_t_3 = PyObject_RichCompare(__pyx_v_mine_collision_time, __pyx_t_10, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3835, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          }
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3835, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_2)) {
            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
            __PYX_ERR(0, 3835, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 3835, __pyx_L1_error)
        #endif

+3836:                     dist_to_ground_zero = dist(self.ship_state.position, mine_pos)

      __pyx_t_7 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_dist); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3836, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3836, __pyx_L1_error) }
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3836, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3836, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_10))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_10);
        assert(__pyx_t_7);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_9, __pyx_v_mine_pos};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3836, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_XDECREF_SET(__pyx_v_dist_to_ground_zero, __pyx_t_3);
      __pyx_t_3 = 0;

 3837:                     # This is a linear function that is maximum when I'm right over the mine, and minimum at 0 when I'm just touching the blast radius of it

 3838:                     # This will penalize being at ground zero more than penalizing being right at the edge of the blast, where it's easier to get out

+3839:                     mine_ground_zero_fudge = linear(dist_to_ground_zero, (0.0, 1.0), (MINE_BLAST_RADIUS + SHIP_RADIUS, 0.6))

      __pyx_t_10 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_linear); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_8 = PyNumber_Add(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GIVEREF(__pyx_t_8);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 3839, __pyx_L1_error);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_6);
      __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_0_6);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_float_0_6) != (0)) __PYX_ERR(0, 3839, __pyx_L1_error);
      __pyx_t_8 = 0;
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_10);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_10);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_v_dist_to_ground_zero, __pyx_mstate_global->__pyx_tuple[20], __pyx_t_6};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3839, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_XDECREF_SET(__pyx_v_mine_ground_zero_fudge, __pyx_t_3);
      __pyx_t_3 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[20] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_float_0_0, __pyx_mstate_global->__pyx_float_1_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[20])) __PYX_ERR(0, 3839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[20]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[20]);

 3840:                     # mine_ground_zero_fudge = max(0.0, (MINE_BLAST_RADIUS + SHIP_RADIUS - dist_to_ground_zero)/(MINE_BLAST_RADIUS + SHIP_RADIUS))

+3841:                     mines_threat_level += (MINE_FUSE_TIME - next_extrapolated_mine_collision_time)**2.0/9.0*mine_ground_zero_fudge

      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = PyNumber_Subtract(__pyx_t_3, __pyx_v_next_extrapolated_mine_collision_time); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyNumber_Power(__pyx_t_9, __pyx_mstate_global->__pyx_float_2_0, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_3, __pyx_mstate_global->__pyx_float_9_0, 9.0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyNumber_Multiply(__pyx_t_9, __pyx_v_mine_ground_zero_fudge); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_v_mines_threat_level, __pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF_SET(__pyx_v_mines_threat_level, __pyx_t_9);
      __pyx_t_9 = 0;

+3842:             mine_safe_time_fitness = sigmoid(mines_threat_level, -6.8, 0.232)

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3842, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_9, __pyx_v_mines_threat_level, __pyx_mstate_global->__pyx_float_neg_6_8, __pyx_mstate_global->__pyx_float_0_232};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3842, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_v_mine_safe_time_fitness = __pyx_t_4;
  __pyx_t_4 = 0;

+3843:             return mine_safe_time_fitness, next_extrapolated_mine_collision_time

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_v_mine_safe_time_fitness);
  __Pyx_GIVEREF(__pyx_v_mine_safe_time_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_mine_safe_time_fitness) != (0)) __PYX_ERR(0, 3843, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_next_extrapolated_mine_collision_time);
  __Pyx_GIVEREF(__pyx_v_next_extrapolated_mine_collision_time);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_next_extrapolated_mine_collision_time) != (0)) __PYX_ERR(0, 3843, __pyx_L1_error);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 3844: 

+3845:         def get_asteroid_aiming_cone_fitness() -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_7get_asteroid_aiming_cone_fitness(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_fitness_7get_asteroid_aiming_cone_fitness = {"get_asteroid_aiming_cone_fitness", (PyCFunction)__pyx_pw_14neo_controller_6Matrix_11get_fitness_7get_asteroid_aiming_cone_fitness, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_7get_asteroid_aiming_cone_fitness(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_asteroid_aiming_cone_fitness (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_11get_fitness_6get_asteroid_aiming_cone_fitness(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_11get_fitness_6get_asteroid_aiming_cone_fitness(PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_outer_scope;
  PyObject *__pyx_v_ship_pos_x = NULL;
  PyObject *__pyx_v_ship_pos_y = NULL;
  PyObject *__pyx_v_ship_heading_rad = NULL;
  PyObject *__pyx_v_asts_within_cone = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_asteroid_aiming_cone_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ship_pos_x);
  __Pyx_XDECREF(__pyx_v_ship_pos_y);
  __Pyx_XDECREF(__pyx_v_ship_heading_rad);
  __Pyx_XDECREF(__pyx_v_asts_within_cone);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3845, __pyx_L1_error)
  __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_fitness_7get_asteroid_aiming_cone_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_locals_get_as_3, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_10, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_v_get_asteroid_aiming_cone_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

+3846:             if not isinf(self.game_state.time_limit) and self.initial_timestep + self.future_timesteps + END_OF_SCENARIO_DONT_CARE_TIMESTEPS >= floor(FPS*self.game_state.time_limit):

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3846, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = (!(isinf(__pyx_t_4) != 0));
  if (__pyx_t_5) {
  } else {
    __pyx_t_1 = __pyx_t_5;
    goto __pyx_L4_bool_binop_done;
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3846, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3846, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_END_OF_SCENARIO_DONT_CARE_TIMEST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3846, __pyx_L1_error) }
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = PyNumber_Multiply(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3846, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3846, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_1 = __pyx_t_5;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 3847:                 # The scenario's done so we don't care about this anymore

+3848:                 return 1.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_1_0;
    goto __pyx_L0;

+3849:             elif self.ship_state.bullets_remaining == 0 and self.ship_state.mines_remaining == 0:

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3849, __pyx_L1_error) }
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3849, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_5) {
  } else {
    __pyx_t_1 = __pyx_t_5;
    goto __pyx_L6_bool_binop_done;
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3849, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3849, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_1 = __pyx_t_5;
  __pyx_L6_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 3850:                 # Can't shoot anyway so don't care about this

+3851:                 return 1.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_1_0;
    goto __pyx_L0;

 3852:             # Iterate over all asteroids and get their heading angle from the ship's final position/heading, and see whether it's within +-30 degrees

 3853:             #ship_heading = self.ship_state.heading

+3854:             ship_pos_x, ship_pos_y = self.ship_state.position

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3854, __pyx_L1_error) }
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
    PyObject* sequence = __pyx_t_2;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 3854, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_3);
    } else {
      __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3854, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_7);
      __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3854, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_3);
    }
    #else
    __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3854, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3854, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    #endif
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_9 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3854, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9);
    index = 0; __pyx_t_7 = __pyx_t_12(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L8_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_7);
    index = 1; __pyx_t_3 = __pyx_t_12(__pyx_t_9); if (unlikely(!__pyx_t_3)) goto __pyx_L8_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_9), 2) < 0) __PYX_ERR(0, 3854, __pyx_L1_error)
    __pyx_t_12 = NULL;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    goto __pyx_L9_unpacking_done;
    __pyx_L8_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_12 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 3854, __pyx_L1_error)
    __pyx_L9_unpacking_done:;
  }
  __pyx_v_ship_pos_x = __pyx_t_7;
  __pyx_t_7 = 0;
  __pyx_v_ship_pos_y = __pyx_t_3;
  __pyx_t_3 = 0;

+3855:             ship_heading_rad = radians(self.ship_state.heading)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3855, __pyx_L1_error) }
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3855, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_ship_heading_rad = __pyx_t_2;
  __pyx_t_2 = 0;

+3856:             asts_within_cone = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_asts_within_cone = __pyx_mstate_global->__pyx_int_0;

+3857:             for a in chain(self.game_state.asteroids, self.forecasted_asteroid_splits):

  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3857, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3857, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3857, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3857, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3857, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3857, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_9, __pyx_t_3};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3857, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_6 = __pyx_t_2; __Pyx_INCREF(__pyx_t_6);
    __pyx_t_13 = 0;
    __pyx_t_14 = NULL;
  } else {
    __pyx_t_13 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3857, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_14 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3857, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_14)) {
      if (likely(PyList_CheckExact(__pyx_t_6))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3857, __pyx_L1_error)
          #endif
          if (__pyx_t_13 >= __pyx_temp) break;
        }
        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_13);
        ++__pyx_t_13;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3857, __pyx_L1_error)
          #endif
          if (__pyx_t_13 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_13));
        #else
        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_13);
        #endif
        ++__pyx_t_13;
      }
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3857, __pyx_L1_error)
    } else {
      __pyx_t_2 = __pyx_t_14(__pyx_t_6);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3857, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 3858:                 # Actually for performance reasons, I think I won’t even check that the asteroid is one we don’t have a pending shot for.

 3859:                 # My logic is that, well first of all, this is a heuristic.

 3860:                 # But also, in what situation would I have already shot at those asteroids?

 3861:                 # If I shot at them way in the past, they would already be dead, and we won’t have a pending shot.

 3862:                 # We’d only have a pending shot if we JUST shot them.

 3863:                 # But say we have case A where I do a maneuver and don’t shoot the asteroids.

 3864:                 # Is that really better than a case where I did a maneuver, but I shot the asteroids and now there’s no asteroids in the cone in front of me? The latter is preferable.

 3865:                 #if check_whether_this_is_a_new_asteroid_we_do_not_have_a_pending_shot_for(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps, self.game_state, a):

 3866: 

+3867:                 if heading_diff_within_threshold(ship_heading_rad, a.position[0] - ship_pos_x, a.position[1] - ship_pos_y, AIMING_CONE_FITNESS_CONE_WIDTH_HALF_COSINE):

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_heading_diff_within_threshold); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyNumber_Subtract(__pyx_t_10, __pyx_v_ship_pos_x); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyNumber_Subtract(__pyx_t_8, __pyx_v_ship_pos_y); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_AIMING_CONE_FITNESS_CONE_WIDTH_H); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_11 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_11 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[5] = {__pyx_t_3, __pyx_v_ship_heading_rad, __pyx_t_7, __pyx_t_10, __pyx_t_8};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (5-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3867, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3867, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_1) {
/* … */
    }

+3868:                     asts_within_cone += 1

      __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_v_asts_within_cone, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3868, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF_SET(__pyx_v_asts_within_cone, __pyx_t_2);
      __pyx_t_2 = 0;

 3869:                 #theta = degrees(super_fast_atan2(a.position[1] - ship_pos[1], a.position[0] - ship_pos[0]))

 3870:                 #if abs(angle_difference_deg(theta, ship_heading)) <= 30.0:

 3871:                 #    asts_within_cone += 1

 3872:                 #if abs(ship_heading - theta) <= 30.0 or abs(360 - abs(ship_heading - theta)) <= 30.0:

 3873:                 #    asts_within_cone += 1

 3874:             '''

 3875:             if asts_within_cone == 0:

 3876:                 asteroid_aiming_cone_score = 0.0

 3877:             elif asts_within_cone == 1:

 3878:                 asteroid_aiming_cone_score = 0.8

 3879:             elif asts_within_cone == 2:

 3880:                 asteroid_aiming_cone_score = 0.85

 3881:             elif asts_within_cone == 3:

 3882:                 asteroid_aiming_cone_score = 0.90

 3883:             elif asts_within_cone == 4:

 3884:                 asteroid_aiming_cone_score = 0.95

 3885:             else:

 3886:                 asteroid_aiming_cone_score = 1.0

 3887:             '''

+3888:             return sigmoid(asts_within_cone, 1.0, 2.4)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_v_asts_within_cone, __pyx_mstate_global->__pyx_float_1_0, __pyx_mstate_global->__pyx_float_2_4};
    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3888, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_r = __pyx_t_6;
  __pyx_t_6 = 0;
  goto __pyx_L0;

 3889: 

+3890:         def get_crash_fitness() -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_9get_crash_fitness(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_fitness_9get_crash_fitness = {"get_crash_fitness", (PyCFunction)__pyx_pw_14neo_controller_6Matrix_11get_fitness_9get_crash_fitness, METH_NOARGS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_9get_crash_fitness(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_crash_fitness (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_11get_fitness_8get_crash_fitness(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_11get_fitness_8get_crash_fitness(PyObject *__pyx_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_outer_scope;
  double __pyx_v_crash_fitness;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_crash_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_10 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3890, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_fitness_9get_crash_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_locals_get_cr, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_10);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_get_crash_fitness = __pyx_t_9;
  __pyx_t_9 = 0;

+3891:             if not isinf(self.game_state.time_limit) and self.initial_timestep + self.future_timesteps + END_OF_SCENARIO_DONT_CARE_TIMESTEPS >= floor(FPS*self.game_state.time_limit):

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3891, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = (!(isinf(__pyx_t_4) != 0));
  if (__pyx_t_5) {
  } else {
    __pyx_t_1 = __pyx_t_5;
    goto __pyx_L4_bool_binop_done;
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3891, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3891, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_END_OF_SCENARIO_DONT_CARE_TIMEST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3891, __pyx_L1_error) }
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = PyNumber_Multiply(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3891, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3891, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_1 = __pyx_t_5;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
    goto __pyx_L3;
  }

 3892:                 # If we're near the end of the scenario, we're gonna fudge things so that we don't care if the ship crashes near the end.

 3893:                 # If anything, sacrificing a life to get another hit is probably optimal behavior, since we don't care about deaths, and we only care about asteroid hits!

+3894:                 crash_fitness = 1.0

    __pyx_v_crash_fitness = 1.0;

 3895:             else:

+3896:                 if self.ship_crashed:

  /*else*/ {
    if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3896, __pyx_L1_error) }
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_crashed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3896, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_1) {
/* … */
      goto __pyx_L6;
    }

+3897:                     if self.ship_state.bullets_remaining == 0 and self.ship_state.mines_remaining == 0:

      if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3897, __pyx_L1_error) }
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3897, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3897, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3897, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (__pyx_t_5) {
      } else {
        __pyx_t_1 = __pyx_t_5;
        goto __pyx_L8_bool_binop_done;
      }
      if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3897, __pyx_L1_error) }
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3897, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3897, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3897, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_1 = __pyx_t_5;
      __pyx_L8_bool_binop_done:;
      if (__pyx_t_1) {
/* … */
        goto __pyx_L7;
      }

+3898:                         crash_fitness = 1.0

        __pyx_v_crash_fitness = 1.0;

 3899:                     else:

+3900:                         crash_fitness = 0.0

      /*else*/ {
        __pyx_v_crash_fitness = 0.0;
      }
      __pyx_L7:;

 3901:                 else:

+3902:                     if self.ship_state.bullets_remaining == 0 and self.ship_state.mines_remaining == 0:

    /*else*/ {
      if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3902, __pyx_L1_error) }
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3902, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3902, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3902, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (__pyx_t_5) {
      } else {
        __pyx_t_1 = __pyx_t_5;
        goto __pyx_L11_bool_binop_done;
      }
      if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3902, __pyx_L1_error) }
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3902, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3902, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_5 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3902, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_1 = __pyx_t_5;
      __pyx_L11_bool_binop_done:;
      if (__pyx_t_1) {
/* … */
        goto __pyx_L10;
      }

+3903:                         crash_fitness = 0.0

        __pyx_v_crash_fitness = 0.0;

 3904:                     else:

+3905:                         crash_fitness = 1.0

      /*else*/ {
        __pyx_v_crash_fitness = 1.0;
      }
      __pyx_L10:;
    }
    __pyx_L6:;
  }
  __pyx_L3:;

+3906:             return crash_fitness

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_crash_fitness); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

 3907: 

+3908:         def get_sequence_length_fitness(move_sequence_length_s: float, displacement: float) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_11get_sequence_length_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_fitness_11get_sequence_length_fitness = {"get_sequence_length_fitness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_11get_fitness_11get_sequence_length_fitness, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_11get_sequence_length_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  double __pyx_v_move_sequence_length_s;
  double __pyx_v_displacement;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_sequence_length_fitness (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_move_sequence_length_s,&__pyx_mstate_global->__pyx_n_u_displacement,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3908, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3908, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3908, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_sequence_length_fitness", 0) < 0) __PYX_ERR(0, 3908, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_sequence_length_fitness", 1, 2, 2, i); __PYX_ERR(0, 3908, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3908, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3908, __pyx_L3_error)
    }
    __pyx_v_move_sequence_length_s = __Pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_move_sequence_length_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3908, __pyx_L3_error)
    __pyx_v_displacement = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_displacement == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3908, __pyx_L3_error)
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_sequence_length_fitness", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3908, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_sequence_length_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_11get_fitness_10get_sequence_length_fitness(__pyx_self, __pyx_v_move_sequence_length_s, __pyx_v_displacement);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_11get_fitness_10get_sequence_length_fitness(PyObject *__pyx_self, double __pyx_v_move_sequence_length_s, double __pyx_v_displacement) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_outer_scope;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_sequence_length_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3908, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_move_sequence_length_s, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3908, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_displacement, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3908, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3908, __pyx_L1_error)
  __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_fitness_11get_sequence_length_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_locals_get_se, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3908, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_10, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_v_get_sequence_length_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

+3909:             if self.respawn_maneuver_pass_number > 0:

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3909, __pyx_L1_error) }
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3909, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3909, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3909, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_3) {
/* … */
  }

 3910:                 # This is a respawn maneuver

+3911:                 return sigmoid(move_sequence_length_s, -2.8, 1.7)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3911, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_move_sequence_length_s); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3911, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_float_neg_2_8, __pyx_mstate_global->__pyx_float_1_7};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3911, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

 3912:             else:

+3913:                 if displacement < EPS:

  /*else*/ {
    __pyx_t_3 = (__pyx_v_displacement < __pyx_v_14neo_controller_EPS);
    if (__pyx_t_3) {
/* … */
    }

 3914:                     # If this is stationary targetting, we give an incentive to do that by discounting the length it takes to aim

 3915:                     # move_sequence_length_s = min(0.25, 0.5*move_sequence_length_s)

 3916:                     # pass

+3917:                     return sigmoid(move_sequence_length_s, -2.8, 1.7)

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_4 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3917, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_move_sequence_length_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3917, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_4);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_t_1, __pyx_mstate_global->__pyx_float_neg_2_8, __pyx_mstate_global->__pyx_float_1_7};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3917, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;

 3918:                 else:

+3919:                     return sigmoid(move_sequence_length_s, -5.7, 0.8)

    /*else*/ {
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3919, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_move_sequence_length_s); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3919, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_1))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_t_4, __pyx_mstate_global->__pyx_float_neg_5_7, __pyx_mstate_global->__pyx_float_0_8};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3919, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      goto __pyx_L0;
    }
  }

 3920: 

+3921:         def get_other_ship_proximity_fitness(self_positions: list[tuple[float, float]]) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_13get_other_ship_proximity_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_11get_fitness_13get_other_ship_proximity_fitness = {"get_other_ship_proximity_fitness", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_11get_fitness_13get_other_ship_proximity_fitness, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_11get_fitness_13get_other_ship_proximity_fitness(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self_positions = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_other_ship_proximity_fitness (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self_positions,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3921, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3921, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_other_ship_proximity_fitness", 0) < 0) __PYX_ERR(0, 3921, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_other_ship_proximity_fitness", 1, 1, 1, i); __PYX_ERR(0, 3921, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3921, __pyx_L3_error)
    }
    __pyx_v_self_positions = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_other_ship_proximity_fitness", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3921, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_other_ship_proximity_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_self_positions), (&PyList_Type), 0, "self_positions", 2))) __PYX_ERR(0, 3921, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_11get_fitness_12get_other_ship_proximity_fitness(__pyx_self, __pyx_v_self_positions);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_11get_fitness_12get_other_ship_proximity_fitness(PyObject *__pyx_self, PyObject *__pyx_v_self_positions) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *__pyx_outer_scope;
  int __pyx_v_invert_ship_affinity;
  PyObject *__pyx_v_other_ship = NULL;
  PyObject *__pyx_v_other_ship_pos_x = NULL;
  PyObject *__pyx_v_other_ship_pos_y = NULL;
  PyObject *__pyx_v_other_ship_vel_x = NULL;
  PyObject *__pyx_v_other_ship_vel_y = NULL;
  double __pyx_v_other_ship_speed;
  PyObject *__pyx_v_other_ship_speed_dist_mul = NULL;
  PyObject *__pyx_v_separation_dists = NULL;
  PyObject *__pyx_v_self_pos = NULL;
  PyObject *__pyx_v_self_pos_x = NULL;
  PyObject *__pyx_v_self_pos_y = NULL;
  PyObject *__pyx_v_abs_sep_x = NULL;
  PyObject *__pyx_v_abs_sep_y = NULL;
  PyObject *__pyx_v_sep_x = NULL;
  PyObject *__pyx_v_sep_y = NULL;
  double __pyx_v_separation_dist;
  PyObject *__pyx_v_mean_separation_dist = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_12_get_fitness *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness.get_other_ship_proximity_fitness", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_other_ship);
  __Pyx_XDECREF(__pyx_v_other_ship_pos_x);
  __Pyx_XDECREF(__pyx_v_other_ship_pos_y);
  __Pyx_XDECREF(__pyx_v_other_ship_vel_x);
  __Pyx_XDECREF(__pyx_v_other_ship_vel_y);
  __Pyx_XDECREF(__pyx_v_other_ship_speed_dist_mul);
  __Pyx_XDECREF(__pyx_v_separation_dists);
  __Pyx_XDECREF(__pyx_v_self_pos);
  __Pyx_XDECREF(__pyx_v_self_pos_x);
  __Pyx_XDECREF(__pyx_v_self_pos_y);
  __Pyx_XDECREF(__pyx_v_abs_sep_x);
  __Pyx_XDECREF(__pyx_v_abs_sep_y);
  __Pyx_XDECREF(__pyx_v_sep_x);
  __Pyx_XDECREF(__pyx_v_sep_y);
  __Pyx_XDECREF(__pyx_v_mean_separation_dist);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_self_positions, __pyx_mstate_global->__pyx_kp_u_list_tuple_float_float) < 0) __PYX_ERR(0, 3921, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 3921, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_11get_fitness_13get_other_ship_proximity_fitness, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_locals_get_ot, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_10);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_get_other_ship_proximity_fitness = __pyx_t_9;
  __pyx_t_9 = 0;

 3922:             # Penalize being too close to the other ship. If the other ship is moving, penalize that as well by effectively treating the distance as closer to the other ship

 3923:             # There is no maximum detection distance.

 3924:             # On a 1000x800 board, the max distance between two ships is 640.3 pixels

 3925: 

 3926:             # If I'm out of bullets and mines, then I actually want to crash into the other ship to try and kill them to make sure they can't get more hits

 3927:             # Alternatively, if our ship is at full health and the other ship is about to die, ram into the other ship to take them out of the competition. Inspired by OMU from XFC 2024.

+3928:             if (self.ship_state.bullets_remaining == 0 and self.ship_state.mines_remaining == 0) or (self.other_ships and ((weighted_average(overall_fitness_record) > 0.55 and self.other_ships[0].lives_remaining == 1 and self.ship_state.lives_remaining >= 3) or (weighted_average(overall_fitness_record) > 0.7 and self.other_ships[0].lives_remaining < self.ship_state.lives_remaining))):

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3928, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!__pyx_t_4) {
    goto __pyx_L5_next_or;
  } else {
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3928, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!__pyx_t_4) {
  } else {
    __pyx_t_1 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_L5_next_or:;
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3928, __pyx_L1_error) }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_4) {
  } else {
    __pyx_t_1 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3928, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_mstate_global->__pyx_float_0_55, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (!__pyx_t_4) {
    goto __pyx_L8_next_or;
  } else {
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3928, __pyx_L1_error) }
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (!__pyx_t_4) {
    goto __pyx_L8_next_or;
  } else {
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3928, __pyx_L1_error) }
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_mstate_global->__pyx_int_3, Py_GE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (!__pyx_t_4) {
  } else {
    __pyx_t_1 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_L8_next_or:;
  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_mstate_global->__pyx_float_0_7, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_4) {
  } else {
    __pyx_t_1 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3928, __pyx_L1_error) }
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3928, __pyx_L1_error) }
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __pyx_t_4;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
    goto __pyx_L3;
  }

+3929:                 invert_ship_affinity = True

    __pyx_v_invert_ship_affinity = 1;

+3930:                 self.explanation_messages.append("I'm either out of bullets/mines or the other ship is about to die, so I'm gonna try to crash into the other ship mwahahahaha")

    if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3930, __pyx_L1_error) }
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3930, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_I_m_either_out_of_bullets_mines); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 3930, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 3931:             else:

+3932:                 invert_ship_affinity = False

  /*else*/ {
    __pyx_v_invert_ship_affinity = 0;
  }
  __pyx_L3:;

+3933:             for other_ship in self.other_ships:

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3933, __pyx_L1_error) }
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3933, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) {
    __pyx_t_3 = __pyx_t_5; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_9 = 0;
    __pyx_t_10 = NULL;
  } else {
    __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3933, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_10 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3933, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  for (;;) {
    if (likely(!__pyx_t_10)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3933, __pyx_L1_error)
          #endif
          if (__pyx_t_9 >= __pyx_temp) break;
        }
        __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_9);
        ++__pyx_t_9;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3933, __pyx_L1_error)
          #endif
          if (__pyx_t_9 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9));
        #else
        __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_9);
        #endif
        ++__pyx_t_9;
      }
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3933, __pyx_L1_error)
    } else {
      __pyx_t_5 = __pyx_t_10(__pyx_t_3);
      if (unlikely(!__pyx_t_5)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3933, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_v_other_ship = __pyx_t_5;
    __pyx_t_5 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  /*else*/ {

 3934:                 # It's assume there's only one ship, so this returns after the first ship is checked

+3935:                 other_ship_pos_x, other_ship_pos_y = other_ship.position

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other_ship, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3935, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
      PyObject* sequence = __pyx_t_5;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 3935, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_6);
        __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_2);
      } else {
        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3935, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_6);
        __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3935, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_2);
      }
      #else
      __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3935, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3935, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      #endif
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_11 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3935, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_11);
      index = 0; __pyx_t_6 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_6)) goto __pyx_L14_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_6);
      index = 1; __pyx_t_2 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_2)) goto __pyx_L14_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_2);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_11), 2) < 0) __PYX_ERR(0, 3935, __pyx_L1_error)
      __pyx_t_12 = NULL;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      goto __pyx_L15_unpacking_done;
      __pyx_L14_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_12 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 3935, __pyx_L1_error)
      __pyx_L15_unpacking_done:;
    }
    __pyx_v_other_ship_pos_x = __pyx_t_6;
    __pyx_t_6 = 0;
    __pyx_v_other_ship_pos_y = __pyx_t_2;
    __pyx_t_2 = 0;

+3936:                 other_ship_vel_x, other_ship_vel_y = other_ship.velocity

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_other_ship, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3936, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
      PyObject* sequence = __pyx_t_5;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 3936, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_2);
        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_6);
      } else {
        __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3936, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_2);
        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3936, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_6);
      }
      #else
      __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3936, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3936, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      #endif
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_11 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3936, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_11);
      index = 0; __pyx_t_2 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_2)) goto __pyx_L16_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_2);
      index = 1; __pyx_t_6 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_6)) goto __pyx_L16_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_11), 2) < 0) __PYX_ERR(0, 3936, __pyx_L1_error)
      __pyx_t_12 = NULL;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      goto __pyx_L17_unpacking_done;
      __pyx_L16_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_12 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 3936, __pyx_L1_error)
      __pyx_L17_unpacking_done:;
    }
    __pyx_v_other_ship_vel_x = __pyx_t_2;
    __pyx_t_2 = 0;
    __pyx_v_other_ship_vel_y = __pyx_t_6;
    __pyx_t_6 = 0;

+3937:                 other_ship_speed = sqrt(other_ship_vel_x*other_ship_vel_x + other_ship_vel_y*other_ship_vel_y)

    __pyx_t_5 = PyNumber_Multiply(__pyx_v_other_ship_vel_x, __pyx_v_other_ship_vel_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3937, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Multiply(__pyx_v_other_ship_vel_y, __pyx_v_other_ship_vel_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3937, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_2 = PyNumber_Add(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3937, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3937, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_other_ship_speed = sqrt(__pyx_t_13);

 3938:                 # prox_score_speed_mul = min(1, other_ship_speed/100)*0.7 + 0.3

 3939:                 # This multiplier effectively decreases the distance between the ships, at least when the fitness function considers it

 3940:                 # If the other ship is stationary, then the multiplier is 1. But if the other ship is moving quickly, I treat the distance between us to be smaller than it actually is, down to 30% the actual distance

+3941:                 other_ship_speed_dist_mul = linear(other_ship_speed, (0, 1), (SHIP_MAX_SPEED, 0.3))

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_linear); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_11 = PyFloat_FromDouble(__pyx_v_other_ship_speed); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_GIVEREF(__pyx_t_14);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_14) != (0)) __PYX_ERR(0, 3941, __pyx_L1_error);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_3);
    __Pyx_GIVEREF(__pyx_mstate_global->__pyx_float_0_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_mstate_global->__pyx_float_0_3) != (0)) __PYX_ERR(0, 3941, __pyx_L1_error);
    __pyx_t_14 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_t_11, __pyx_mstate_global->__pyx_tuple[21], __pyx_t_15};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3941, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_v_other_ship_speed_dist_mul = __pyx_t_2;
    __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[21] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[21])) __PYX_ERR(0, 3941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[21]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[21]);

 3942:                 #total_separation_dist = 0.0

+3943:                 separation_dists = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3943, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_v_separation_dists = ((PyObject*)__pyx_t_2);
    __pyx_t_2 = 0;

+3944:                 for self_pos in self_positions:

    __pyx_t_2 = __pyx_v_self_positions; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_16 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3944, __pyx_L1_error)
        #endif
        if (__pyx_t_16 >= __pyx_temp) break;
      }
      __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_16);
      ++__pyx_t_16;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3944, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_XDECREF_SET(__pyx_v_self_pos, __pyx_t_5);
      __pyx_t_5 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+3945:                     self_pos_x, self_pos_y = self_pos  # self.ship_state.position

      if ((likely(PyTuple_CheckExact(__pyx_v_self_pos))) || (PyList_CheckExact(__pyx_v_self_pos))) {
        PyObject* sequence = __pyx_v_self_pos;
        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
        if (unlikely(size != 2)) {
          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
          __PYX_ERR(0, 3945, __pyx_L1_error)
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        if (likely(PyTuple_CheckExact(sequence))) {
          __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0);
          __Pyx_INCREF(__pyx_t_5);
          __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1);
          __Pyx_INCREF(__pyx_t_15);
        } else {
          __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0);
          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3945, __pyx_L1_error)
          __Pyx_XGOTREF(__pyx_t_5);
          __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 1);
          if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3945, __pyx_L1_error)
          __Pyx_XGOTREF(__pyx_t_15);
        }
        #else
        __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3945, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3945, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        #endif
      } else {
        Py_ssize_t index = -1;
        __pyx_t_11 = PyObject_GetIter(__pyx_v_self_pos); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3945, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_11);
        index = 0; __pyx_t_5 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_5)) goto __pyx_L20_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_5);
        index = 1; __pyx_t_15 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_15)) goto __pyx_L20_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_15);
        if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_11), 2) < 0) __PYX_ERR(0, 3945, __pyx_L1_error)
        __pyx_t_12 = NULL;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        goto __pyx_L21_unpacking_done;
        __pyx_L20_unpacking_failed:;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __pyx_t_12 = NULL;
        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
        __PYX_ERR(0, 3945, __pyx_L1_error)
        __pyx_L21_unpacking_done:;
      }
      __Pyx_XDECREF_SET(__pyx_v_self_pos_x, __pyx_t_5);
      __pyx_t_5 = 0;
      __Pyx_XDECREF_SET(__pyx_v_self_pos_y, __pyx_t_15);
      __pyx_t_15 = 0;

 3946:                     # Account for wrap. We know that the farthest two objects can be separated within the screen in the x and y axes, is by half the width, and half the height

+3947:                     abs_sep_x = abs(self_pos_x - other_ship_pos_x)

      __pyx_t_15 = PyNumber_Subtract(__pyx_v_self_pos_x, __pyx_v_other_ship_pos_x); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3947, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3947, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_XDECREF_SET(__pyx_v_abs_sep_x, __pyx_t_5);
      __pyx_t_5 = 0;

+3948:                     abs_sep_y = abs(self_pos_y - other_ship_pos_y)

      __pyx_t_5 = PyNumber_Subtract(__pyx_v_self_pos_y, __pyx_v_other_ship_pos_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3948, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_15 = __Pyx_PyNumber_Absolute(__pyx_t_5); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3948, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF_SET(__pyx_v_abs_sep_y, __pyx_t_15);
      __pyx_t_15 = 0;

+3949:                     sep_x = min(abs_sep_x, self.game_state.map_size[0] - abs_sep_x)

      if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3949, __pyx_L1_error) }
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3949, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3949, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3949, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = PyNumber_Subtract(__pyx_t_15, __pyx_v_abs_sep_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3949, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_INCREF(__pyx_v_abs_sep_x);
      __pyx_t_15 = __pyx_v_abs_sep_x;
      __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_15, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3949, __pyx_L1_error)
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3949, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (__pyx_t_1) {
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_11 = __pyx_t_5;
      } else {
        __Pyx_INCREF(__pyx_t_15);
        __pyx_t_11 = __pyx_t_15;
      }
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __pyx_t_11;
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_XDECREF_SET(__pyx_v_sep_x, __pyx_t_5);
      __pyx_t_5 = 0;

+3950:                     sep_y = min(abs_sep_y, self.game_state.map_size[1] - abs_sep_y)

      if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 3950, __pyx_L1_error) }
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3950, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3950, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_11, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3950, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = PyNumber_Subtract(__pyx_t_5, __pyx_v_abs_sep_y); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3950, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_INCREF(__pyx_v_abs_sep_y);
      __pyx_t_5 = __pyx_v_abs_sep_y;
      __pyx_t_6 = PyObject_RichCompare(__pyx_t_11, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3950, __pyx_L1_error)
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3950, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (__pyx_t_1) {
        __Pyx_INCREF(__pyx_t_11);
        __pyx_t_15 = __pyx_t_11;
      } else {
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_15 = __pyx_t_5;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = __pyx_t_15;
      __Pyx_INCREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_XDECREF_SET(__pyx_v_sep_y, __pyx_t_11);
      __pyx_t_11 = 0;

+3951:                     separation_dist = sqrt(sep_x*sep_x + sep_y*sep_y)

      __pyx_t_11 = PyNumber_Multiply(__pyx_v_sep_x, __pyx_v_sep_x); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3951, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_15 = PyNumber_Multiply(__pyx_v_sep_y, __pyx_v_sep_y); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3951, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_5 = PyNumber_Add(__pyx_t_11, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3951, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3951, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_v_separation_dist = sqrt(__pyx_t_13);

 3952:                     #total_separation_dist += separation_dist

+3953:                     separation_dists.append(separation_dist)

      __pyx_t_5 = PyFloat_FromDouble(__pyx_v_separation_dist); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3953, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_separation_dists, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 3953, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 3954:                 # TODO: Maybe weigh the more recent separation distances more than the earlier ones

 3955:                 #mean_separation_dist = total_separation_dist/len(self_positions)

+3956:                 mean_separation_dist = weighted_harmonic_mean(separation_dists)

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_weighted_harmonic_mean); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3956, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_15))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_15);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_15, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_separation_dists};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3956, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_v_mean_separation_dist = __pyx_t_2;
    __pyx_t_2 = 0;

 3957:                 #print(f"{self.sim_id=} {separation_dists=} {mean_separation_dist=}")

 3958:                 # other_ship_proximity_fitness += prox_score_speed_mul*ship_proximity_max_penalty/(ship_proximity_detection_radius**ship_prox_exponent)*(ship_proximity_detection_radius - separation_dist)**ship_prox_exponent

+3959:                 return 1.0 - sigmoid(mean_separation_dist*other_ship_speed_dist_mul, 0.032, 120) if invert_ship_affinity else sigmoid(mean_separation_dist*other_ship_speed_dist_mul, 0.032, 120)

    __Pyx_XDECREF(__pyx_r);
    if (__pyx_v_invert_ship_affinity) {
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3959, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_6 = PyNumber_Multiply(__pyx_v_mean_separation_dist, __pyx_v_other_ship_speed_dist_mul); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3959, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_11))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_t_6, __pyx_mstate_global->__pyx_float_0_032, __pyx_mstate_global->__pyx_int_120};
        __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3959, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
      }
      __pyx_t_11 = __Pyx_PyFloat_SubtractCObj(__pyx_mstate_global->__pyx_float_1_0, __pyx_t_15, 1.0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3959, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_2 = __pyx_t_11;
      __pyx_t_11 = 0;
    } else {
      __pyx_t_15 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3959, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = PyNumber_Multiply(__pyx_v_mean_separation_dist, __pyx_v_other_ship_speed_dist_mul); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3959, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_15);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_15);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_15, __pyx_t_5, __pyx_mstate_global->__pyx_float_0_032, __pyx_mstate_global->__pyx_int_120};
        __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3959, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
      }
      __pyx_t_2 = __pyx_t_11;
      __pyx_t_11 = 0;
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L0;

 3960:             else:

+3961:                 return 1.0

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
    __pyx_r = __pyx_mstate_global->__pyx_float_1_0;
    goto __pyx_L0;
  }

 3962: 

 3963:         # Grab the states first before they get screwed up

+3964:         states = self.get_state_sequence()

  __pyx_t_10 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_10);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
    __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_state_sequence, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3964, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  __pyx_v_states = __pyx_t_9;
  __pyx_t_9 = 0;

 3965: 

+3966:         move_sequence_length_s = float(self.get_sequence_length() - 1)*DELTA_TIME

  __pyx_t_10 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_10);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
    __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_sequence_length, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3966, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  __pyx_t_10 = __Pyx_PyLong_SubtractObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3966, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __Pyx_PyNumber_Float(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3966, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3966, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3966, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_move_sequence_length_s = __pyx_t_6;
  __pyx_t_6 = 0;

 3967:         # print(f"{self.ship_state.position=}, {self.ship_state.velocity=}, {self.ship_state.speed=} maneuver length: {move_sequence_length_s}")

+3968:         next_extrapolated_mine_collision_times = self.get_next_extrapolated_mine_collision_times_and_pos()

  __pyx_t_10 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_10);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
    __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_next_extrapolated_mine_colli, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3968, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_v_next_extrapolated_mine_collision_times = __pyx_t_6;
  __pyx_t_6 = 0;

 3969: 

+3970:         mine_safe_time_fitness, next_extrapolated_mine_collision_time = get_mine_safety_fitness(next_extrapolated_mine_collision_times)

  if (!(likely(PyList_CheckExact(__pyx_v_next_extrapolated_mine_collision_times))||((__pyx_v_next_extrapolated_mine_collision_times) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_v_next_extrapolated_mine_collision_times))) __PYX_ERR(0, 3970, __pyx_L1_error)
  __pyx_t_6 = __pyx_pf_14neo_controller_6Matrix_11get_fitness_4get_mine_safety_fitness(__pyx_v_get_mine_safety_fitness, ((PyObject*)__pyx_v_next_extrapolated_mine_collision_times)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3970, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
    PyObject* sequence = __pyx_t_6;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 3970, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_9);
    } else {
      __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3970, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3970, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_9);
    }
    #else
    __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3970, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3970, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    #endif
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_4 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3970, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4);
    index = 0; __pyx_t_10 = __pyx_t_12(__pyx_t_4); if (unlikely(!__pyx_t_10)) goto __pyx_L4_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_10);
    index = 1; __pyx_t_9 = __pyx_t_12(__pyx_t_4); if (unlikely(!__pyx_t_9)) goto __pyx_L4_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_4), 2) < 0) __PYX_ERR(0, 3970, __pyx_L1_error)
    __pyx_t_12 = NULL;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L5_unpacking_done;
    __pyx_L4_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_12 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 3970, __pyx_L1_error)
    __pyx_L5_unpacking_done:;
  }
  __pyx_v_mine_safe_time_fitness = __pyx_t_10;
  __pyx_t_10 = 0;
  __pyx_v_next_extrapolated_mine_collision_time = __pyx_t_9;
  __pyx_t_9 = 0;

+3971:         asteroids_fitness = get_asteroid_shot_frequency_fitness(self.asteroids_shot, move_sequence_length_s)

  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3971, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (!(likely(PyLong_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_6))) __PYX_ERR(0, 3971, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_move_sequence_length_s); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3971, __pyx_L1_error)
  __pyx_t_9 = __pyx_pf_14neo_controller_6Matrix_11get_fitness_2get_asteroid_shot_frequency_fitness(__pyx_v_get_asteroid_shot_frequency_fitness, ((PyObject*)__pyx_t_6), __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3971, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_asteroids_fitness = __pyx_t_9;
  __pyx_t_9 = 0;

+3972:         asteroid_aiming_cone_fitness = get_asteroid_aiming_cone_fitness()

  __pyx_t_9 = __pyx_pf_14neo_controller_6Matrix_11get_fitness_6get_asteroid_aiming_cone_fitness(__pyx_v_get_asteroid_aiming_cone_fitness); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3972, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_v_asteroid_aiming_cone_fitness = __pyx_t_9;
  __pyx_t_9 = 0;

 3973: 

 3974:         # If mines still have yet to blow up, what we're gonna do is simulate the game until the mines blow up and we know how the mines will blast the asteroids

 3975:         # That way, we can accurately tell what the next extrapolated asteroid collision time is

+3976:         additional_timesteps_to_blow_up_mines = 0

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_v_additional_timesteps_to_blow_up_mines = __pyx_mstate_global->__pyx_int_0;

+3977:         next_extrapolated_asteroid_collision_time = self.get_next_extrapolated_asteroid_collision_time()

  __pyx_t_6 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
    __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_next_extrapolated_asteroid_c, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3977, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  __pyx_v_next_extrapolated_asteroid_collision_time = __pyx_t_9;
  __pyx_t_9 = 0;

+3978:         if self.game_state.mines:

  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3978, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3978, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3978, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_2) {
/* … */
  }

 3979:             # Alternative to doing a deepcopy. Selectively copy the asteroids, mines, and bullets.

+3980:             self.backed_up_game_state_before_post_mutation = self.game_state.copy()

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3980, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = __pyx_t_10;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL};
      __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3980, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backed_up_game_state_before_post, __pyx_t_6) < 0) __PYX_ERR(0, 3980, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+3981:             self.backed_up_game_state_before_post_mutation.asteroids = [a.copy() for a in self.game_state.asteroids]

    { /* enter inner scope */
      __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3981, __pyx_L9_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3981, __pyx_L9_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3981, __pyx_L9_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
        __pyx_t_10 = __pyx_t_9; __Pyx_INCREF(__pyx_t_10);
        __pyx_t_14 = 0;
        __pyx_t_15 = NULL;
      } else {
        __pyx_t_14 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3981, __pyx_L9_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3981, __pyx_L9_error)
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      for (;;) {
        if (likely(!__pyx_t_15)) {
          if (likely(PyList_CheckExact(__pyx_t_10))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3981, __pyx_L9_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_14);
            ++__pyx_t_14;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3981, __pyx_L9_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_14));
            #else
            __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_14);
            #endif
            ++__pyx_t_14;
          }
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3981, __pyx_L9_error)
        } else {
          __pyx_t_9 = __pyx_t_15(__pyx_t_10);
          if (unlikely(!__pyx_t_9)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3981, __pyx_L9_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_XDECREF_SET(__pyx_9genexpr29__pyx_v_a, __pyx_t_9);
        __pyx_t_9 = 0;
        __pyx_t_4 = __pyx_9genexpr29__pyx_v_a;
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
          __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3981, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 3981, __pyx_L9_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      }
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_9genexpr29__pyx_v_a); __pyx_9genexpr29__pyx_v_a = 0;
      goto __pyx_L13_exit_scope;
      __pyx_L9_error:;
      __Pyx_XDECREF(__pyx_9genexpr29__pyx_v_a); __pyx_9genexpr29__pyx_v_a = 0;
      goto __pyx_L1_error;
      __pyx_L13_exit_scope:;
    } /* exit inner scope */
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backed_up_game_state_before_post); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3981, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_6) < 0) __PYX_ERR(0, 3981, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+3982:             self.backed_up_game_state_before_post_mutation.mines = [m.copy() for m in self.game_state.mines]

    { /* enter inner scope */
      __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3982, __pyx_L16_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3982, __pyx_L16_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3982, __pyx_L16_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
        __pyx_t_6 = __pyx_t_9; __Pyx_INCREF(__pyx_t_6);
        __pyx_t_14 = 0;
        __pyx_t_15 = NULL;
      } else {
        __pyx_t_14 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3982, __pyx_L16_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3982, __pyx_L16_error)
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      for (;;) {
        if (likely(!__pyx_t_15)) {
          if (likely(PyList_CheckExact(__pyx_t_6))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3982, __pyx_L16_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_14);
            ++__pyx_t_14;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3982, __pyx_L16_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_14));
            #else
            __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_14);
            #endif
            ++__pyx_t_14;
          }
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3982, __pyx_L16_error)
        } else {
          __pyx_t_9 = __pyx_t_15(__pyx_t_6);
          if (unlikely(!__pyx_t_9)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3982, __pyx_L16_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_XDECREF_SET(__pyx_9genexpr30__pyx_v_m, __pyx_t_9);
        __pyx_t_9 = 0;
        __pyx_t_4 = __pyx_9genexpr30__pyx_v_m;
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
          __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3982, __pyx_L16_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_10, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 3982, __pyx_L16_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      }
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_9genexpr30__pyx_v_m); __pyx_9genexpr30__pyx_v_m = 0;
      goto __pyx_L20_exit_scope;
      __pyx_L16_error:;
      __Pyx_XDECREF(__pyx_9genexpr30__pyx_v_m); __pyx_9genexpr30__pyx_v_m = 0;
      goto __pyx_L1_error;
      __pyx_L20_exit_scope:;
    } /* exit inner scope */
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backed_up_game_state_before_post); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3982, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_mines, __pyx_t_10) < 0) __PYX_ERR(0, 3982, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+3983:             self.backed_up_game_state_before_post_mutation.bullets = [b.copy() for b in self.game_state.bullets]

    { /* enter inner scope */
      __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3983, __pyx_L23_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3983, __pyx_L23_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3983, __pyx_L23_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
        __pyx_t_10 = __pyx_t_9; __Pyx_INCREF(__pyx_t_10);
        __pyx_t_14 = 0;
        __pyx_t_15 = NULL;
      } else {
        __pyx_t_14 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3983, __pyx_L23_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 3983, __pyx_L23_error)
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      for (;;) {
        if (likely(!__pyx_t_15)) {
          if (likely(PyList_CheckExact(__pyx_t_10))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3983, __pyx_L23_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_14);
            ++__pyx_t_14;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3983, __pyx_L23_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_14));
            #else
            __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_14);
            #endif
            ++__pyx_t_14;
          }
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3983, __pyx_L23_error)
        } else {
          __pyx_t_9 = __pyx_t_15(__pyx_t_10);
          if (unlikely(!__pyx_t_9)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 3983, __pyx_L23_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_XDECREF_SET(__pyx_9genexpr31__pyx_v_b, __pyx_t_9);
        __pyx_t_9 = 0;
        __pyx_t_4 = __pyx_9genexpr31__pyx_v_b;
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
          __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3983, __pyx_L23_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 3983, __pyx_L23_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      }
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_9genexpr31__pyx_v_b); __pyx_9genexpr31__pyx_v_b = 0;
      goto __pyx_L27_exit_scope;
      __pyx_L23_error:;
      __Pyx_XDECREF(__pyx_9genexpr31__pyx_v_b); __pyx_9genexpr31__pyx_v_b = 0;
      goto __pyx_L1_error;
      __pyx_L27_exit_scope:;
    } /* exit inner scope */
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backed_up_game_state_before_post); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3983, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_6) < 0) __PYX_ERR(0, 3983, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+3984:             while self.game_state.mines:

    while (1) {
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3984, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3984, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3984, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (!__pyx_t_2) break;

+3985:                 additional_timesteps_to_blow_up_mines += 1

      __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_v_additional_timesteps_to_blow_up_mines, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3985, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF_SET(__pyx_v_additional_timesteps_to_blow_up_mines, __pyx_t_6);
      __pyx_t_6 = 0;

 3986:                 # print(f"Calling update from get fitness to wait out mines:")

+3987:                 self.update(0.0, 0.0, False, False, None, True)

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3987, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[22], NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3987, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    }
/* … */
  __pyx_mstate_global->__pyx_tuple[22] = PyTuple_Pack(6, __pyx_mstate_global->__pyx_float_0_0, __pyx_mstate_global->__pyx_float_0_0, Py_False, Py_False, Py_None, Py_True); if (unlikely(!__pyx_mstate_global->__pyx_tuple[22])) __PYX_ERR(0, 3987, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[22]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[22]);

 3988:         # if additional_timesteps_to_blow_up_mines != 0:

 3989:         #    debug_print(f"In get fitness, waited an additional {additional_timesteps_to_blow_up_mines} timesteps to blow up mines!")

+3990:         if additional_timesteps_to_blow_up_mines == 0:

  __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_additional_timesteps_to_blow_up_mines, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3990, __pyx_L1_error)
  if (__pyx_t_2) {
/* … */
    goto __pyx_L30;
  }

 3991:             # No mines exist, and it's a straightforward prediction for asteroid collisions

+3992:             assert isinf(next_extrapolated_mine_collision_time)  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_16 = __Pyx_PyFloat_AsDouble(__pyx_v_next_extrapolated_mine_collision_time); if (unlikely((__pyx_t_16 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3992, __pyx_L1_error)
      __pyx_t_2 = (isinf(__pyx_t_16) != 0);
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 3992, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 3992, __pyx_L1_error)
    #endif

+3993:             safe_time_after_maneuver_s = min(next_extrapolated_asteroid_collision_time, next_extrapolated_mine_collision_time)

    __Pyx_INCREF(__pyx_v_next_extrapolated_mine_collision_time);
    __pyx_t_10 = __pyx_v_next_extrapolated_mine_collision_time;
    __Pyx_INCREF(__pyx_v_next_extrapolated_asteroid_collision_time);
    __pyx_t_6 = __pyx_v_next_extrapolated_asteroid_collision_time;
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_10, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3993, __pyx_L1_error)
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3993, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__pyx_t_2) {
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_9 = __pyx_t_10;
    } else {
      __Pyx_INCREF(__pyx_t_6);
      __pyx_t_9 = __pyx_t_6;
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __pyx_t_9;
    __Pyx_INCREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_v_safe_time_after_maneuver_s = __pyx_t_10;
    __pyx_t_10 = 0;

 3994:         else:

 3995:             # Because mines existed and blew up which changed the trajectory of asteroids, we need to do a prediction before and after the mine blew up, and predict both paths

 3996:             # This doesn't properly account for multiple mines! But that's alright, I don't want to make this too complicated and have to do an asteroids prediction after every mine blows up and split the timeline into intervals where asteroids change trajectories, although that is possible to implement

+3997:             next_extrapolated_asteroid_collision_time_after_mines = self.get_next_extrapolated_asteroid_collision_time(additional_timesteps_to_blow_up_mines)

  /*else*/ {
    __pyx_t_9 = __pyx_cur_scope->__pyx_v_self;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_additional_timesteps_to_blow_up_mines};
      __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_next_extrapolated_asteroid_c, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3997, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
    }
    __pyx_v_next_extrapolated_asteroid_collision_time_after_mines = __pyx_t_10;
    __pyx_t_10 = 0;

+3998:             if not isinf(next_extrapolated_asteroid_collision_time) and next_extrapolated_asteroid_collision_time <= additional_timesteps_to_blow_up_mines*DELTA_TIME:

    __pyx_t_16 = __Pyx_PyFloat_AsDouble(__pyx_v_next_extrapolated_asteroid_collision_time); if (unlikely((__pyx_t_16 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3998, __pyx_L1_error)
    __pyx_t_17 = (!(isinf(__pyx_t_16) != 0));
    if (__pyx_t_17) {
    } else {
      __pyx_t_2 = __pyx_t_17;
      goto __pyx_L32_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3998, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = PyNumber_Multiply(__pyx_v_additional_timesteps_to_blow_up_mines, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3998, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyObject_RichCompare(__pyx_v_next_extrapolated_asteroid_collision_time, __pyx_t_9, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3998, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 3998, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_2 = __pyx_t_17;
    __pyx_L32_bool_binop_done:;
    if (__pyx_t_2) {
/* … */
      goto __pyx_L31;
    }

 3999:                 # Before the mine blows up, the ship will get hit by an asteroid if we stay here

+4000:                 safe_time_after_maneuver_s = min(next_extrapolated_asteroid_collision_time, next_extrapolated_asteroid_collision_time_after_mines, next_extrapolated_mine_collision_time)

      __Pyx_INCREF(__pyx_v_next_extrapolated_asteroid_collision_time_after_mines);
      __pyx_t_10 = __pyx_v_next_extrapolated_asteroid_collision_time_after_mines;
      __Pyx_INCREF(__pyx_v_next_extrapolated_mine_collision_time);
      __pyx_t_9 = __pyx_v_next_extrapolated_mine_collision_time;
      __Pyx_INCREF(__pyx_v_next_extrapolated_asteroid_collision_time);
      __pyx_t_6 = __pyx_v_next_extrapolated_asteroid_collision_time;
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_10, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4000, __pyx_L1_error)
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4000, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_2) {
        __Pyx_INCREF(__pyx_t_10);
        __pyx_t_4 = __pyx_t_10;
      } else {
        __Pyx_INCREF(__pyx_t_6);
        __pyx_t_4 = __pyx_t_6;
      }
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_6 = __pyx_t_4;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_9, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4000, __pyx_L1_error)
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4000, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_2) {
        __Pyx_INCREF(__pyx_t_9);
        __pyx_t_4 = __pyx_t_9;
      } else {
        __Pyx_INCREF(__pyx_t_6);
        __pyx_t_4 = __pyx_t_6;
      }
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __pyx_t_4;
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_v_safe_time_after_maneuver_s = __pyx_t_10;
      __pyx_t_10 = 0;

 4001:                 # This assertion is false because it doesn't take into account the existence of other mines. If there was a mine about to blow up, and another fresh mine, then the first mine can blow me up before an asteroid or the fresh mine hits me

 4002:                 #assert is_close(safe_time_after_maneuver_s, next_extrapolated_asteroid_collision_time), f"{safe_time_after_maneuver_s=} != {next_extrapolated_asteroid_collision_time=}, and {next_extrapolated_asteroid_collision_time_after_mines=}, {next_extrapolated_mine_collision_time=}, {additional_timesteps_to_blow_up_mines*DELTA_TIME=}"

 4003:             else:

+4004:                 safe_time_after_maneuver_s = min(next_extrapolated_asteroid_collision_time_after_mines, next_extrapolated_mine_collision_time)

    /*else*/ {
      __Pyx_INCREF(__pyx_v_next_extrapolated_mine_collision_time);
      __pyx_t_10 = __pyx_v_next_extrapolated_mine_collision_time;
      __Pyx_INCREF(__pyx_v_next_extrapolated_asteroid_collision_time_after_mines);
      __pyx_t_4 = __pyx_v_next_extrapolated_asteroid_collision_time_after_mines;
      __pyx_t_6 = PyObject_RichCompare(__pyx_t_10, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4004, __pyx_L1_error)
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4004, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (__pyx_t_2) {
        __Pyx_INCREF(__pyx_t_10);
        __pyx_t_9 = __pyx_t_10;
      } else {
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_9 = __pyx_t_4;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __pyx_t_9;
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_v_safe_time_after_maneuver_s = __pyx_t_10;
      __pyx_t_10 = 0;
    }
    __pyx_L31:;
  }
  __pyx_L30:;

 4005:         # if not isinf(next_extrapolated_asteroid_collision_time_before_mines_blew_up):

 4006:         #    print(f"Next extrap time before mines: {next_extrapolated_asteroid_collision_time_before_mines_blew_up}, and after mines: {next_extrapolated_asteroid_collision_time}, and we waited this many ts for mines to blow up: {additional_timesteps_to_blow_up_mines} which is {additional_timesteps_to_blow_up_mines*DELTA_TIME}s")

 4007:         #states = self.get_state_sequence()

+4008:         overall_safe_time_fitness = sigmoid(safe_time_after_maneuver_s, 2.9, 1.4)

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sigmoid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4008, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_9, __pyx_v_safe_time_after_maneuver_s, __pyx_mstate_global->__pyx_float_2_9, __pyx_mstate_global->__pyx_float_1_4};
    __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4008, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }
  __pyx_v_overall_safe_time_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

 4009: 

+4010:         ship_start_position = states[0].ship_state.position

  __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_states, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4010, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4010, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4010, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_ship_start_position = __pyx_t_10;
  __pyx_t_10 = 0;

+4011:         ship_end_position = states[-1].ship_state.position

  __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_states, -1L, long, 1, __Pyx_PyLong_From_long, 0, 1, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4011, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4011, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4011, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_ship_end_position = __pyx_t_10;
  __pyx_t_10 = 0;

 4012: 

+4013:         if len(states) >= 2:

  __pyx_t_14 = PyObject_Length(__pyx_v_states); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4013, __pyx_L1_error)
  __pyx_t_2 = (__pyx_t_14 >= 2);
  if (__pyx_t_2) {
/* … */
    goto __pyx_L34;
  }

+4014:             displacement = dist(ship_start_position, ship_end_position)

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_dist); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4014, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_ship_start_position, __pyx_v_ship_end_position};
      __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4014, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
    }
    __pyx_v_displacement = __pyx_t_10;
    __pyx_t_10 = 0;

 4015:         else:

+4016:             displacement = 0.0

  /*else*/ {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_v_displacement = __pyx_mstate_global->__pyx_float_0_0;
  }
  __pyx_L34:;

+4017:         asteroid_safe_time_fitness = get_asteroid_safe_time_fitness(next_extrapolated_asteroid_collision_time, displacement, move_sequence_length_s)

  __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_next_extrapolated_asteroid_collision_time); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4017, __pyx_L1_error)
  __pyx_t_18 = __Pyx_PyFloat_AsDouble(__pyx_v_displacement); if (unlikely((__pyx_t_18 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4017, __pyx_L1_error)
  __pyx_t_19 = __Pyx_PyFloat_AsDouble(__pyx_v_move_sequence_length_s); if (unlikely((__pyx_t_19 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4017, __pyx_L1_error)
  __pyx_t_10 = __pyx_pf_14neo_controller_6Matrix_11get_fitness_get_asteroid_safe_time_fitness(__pyx_v_get_asteroid_safe_time_fitness, __pyx_t_13, __pyx_t_18, __pyx_t_19); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_v_asteroid_safe_time_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

+4018:         if displacement < EPS or self.respawn_maneuver_pass_number > 0:

  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4018, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_9 = PyObject_RichCompare(__pyx_v_displacement, __pyx_t_10, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4018, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4018, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (!__pyx_t_17) {
  } else {
    __pyx_t_2 = __pyx_t_17;
    goto __pyx_L36_bool_binop_done;
  }
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4018, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = PyObject_RichCompare(__pyx_t_9, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4018, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4018, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_2 = __pyx_t_17;
  __pyx_L36_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L35;
  }

 4019:             # Stationary targeting or respawn maneuver

+4020:             self_ship_positions = [ship_end_position]

    __pyx_t_10 = PyList_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4020, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_INCREF(__pyx_v_ship_end_position);
    __Pyx_GIVEREF(__pyx_v_ship_end_position);
    if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_v_ship_end_position) != (0)) __PYX_ERR(0, 4020, __pyx_L1_error);
    __pyx_v_self_ship_positions = ((PyObject*)__pyx_t_10);
    __pyx_t_10 = 0;

 4021:         else:

 4022:             # Regular maneuver

 4023:             #self_ship_positions = [states[len(states)//2]['ship_state'].position, states[len(states)*3//4]['ship_state'].position, ship_end_position]

+4024:             self_ship_positions = [s.ship_state.position for s in states]

  /*else*/ {
    { /* enter inner scope */
      __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4024, __pyx_L40_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (likely(PyList_CheckExact(__pyx_v_states)) || PyTuple_CheckExact(__pyx_v_states)) {
        __pyx_t_9 = __pyx_v_states; __Pyx_INCREF(__pyx_t_9);
        __pyx_t_14 = 0;
        __pyx_t_15 = NULL;
      } else {
        __pyx_t_14 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_v_states); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4024, __pyx_L40_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4024, __pyx_L40_error)
      }
      for (;;) {
        if (likely(!__pyx_t_15)) {
          if (likely(PyList_CheckExact(__pyx_t_9))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4024, __pyx_L40_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_14);
            ++__pyx_t_14;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4024, __pyx_L40_error)
              #endif
              if (__pyx_t_14 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_14));
            #else
            __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_14);
            #endif
            ++__pyx_t_14;
          }
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4024, __pyx_L40_error)
        } else {
          __pyx_t_4 = __pyx_t_15(__pyx_t_9);
          if (unlikely(!__pyx_t_4)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4024, __pyx_L40_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_XDECREF_SET(__pyx_9genexpr32__pyx_v_s, __pyx_t_4);
        __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr32__pyx_v_s, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4024, __pyx_L40_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4024, __pyx_L40_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_10, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 4024, __pyx_L40_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_XDECREF(__pyx_9genexpr32__pyx_v_s); __pyx_9genexpr32__pyx_v_s = 0;
      goto __pyx_L44_exit_scope;
      __pyx_L40_error:;
      __Pyx_XDECREF(__pyx_9genexpr32__pyx_v_s); __pyx_9genexpr32__pyx_v_s = 0;
      goto __pyx_L1_error;
      __pyx_L44_exit_scope:;
    } /* exit inner scope */
    __pyx_v_self_ship_positions = ((PyObject*)__pyx_t_10);
    __pyx_t_10 = 0;
  }
  __pyx_L35:;

 4025:             # This assertion won't hold when the ship takes a long time to rotate at the start

 4026:             # assert not (isclose(ship_start_position[0], self_ship_positions[0][0]) and isclose(ship_start_position[1], self_ship_positions[0][1])), f"Ship states: {[s['ship_state'] for s in states]}"

 4027: 

+4028:         other_ship_proximity_fitness = get_other_ship_proximity_fitness(self_ship_positions)

  __pyx_t_10 = __pyx_pf_14neo_controller_6Matrix_11get_fitness_12get_other_ship_proximity_fitness(__pyx_v_get_other_ship_proximity_fitness, __pyx_v_self_ship_positions); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4028, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_v_other_ship_proximity_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

+4029:         sequence_length_fitness = get_sequence_length_fitness(move_sequence_length_s, displacement)

  __pyx_t_19 = __Pyx_PyFloat_AsDouble(__pyx_v_move_sequence_length_s); if (unlikely((__pyx_t_19 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4029, __pyx_L1_error)
  __pyx_t_18 = __Pyx_PyFloat_AsDouble(__pyx_v_displacement); if (unlikely((__pyx_t_18 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4029, __pyx_L1_error)
  __pyx_t_10 = __pyx_pf_14neo_controller_6Matrix_11get_fitness_10get_sequence_length_fitness(__pyx_v_get_sequence_length_fitness, __pyx_t_19, __pyx_t_18); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4029, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_v_sequence_length_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

 4030: 

+4031:         crash_fitness = get_crash_fitness()

  __pyx_t_10 = __pyx_pf_14neo_controller_6Matrix_11get_fitness_8get_crash_fitness(__pyx_v_get_crash_fitness); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4031, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_v_crash_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

 4032: 

+4033:         if self.sim_placed_a_mine:

  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sim_placed_a_mine); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4033, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4033, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L45;
  }

 4034:             #if mine_safe_time_fitness > 0.8:

 4035:             #    placed_mine_fitness = 1.0

 4036:             #else:

 4037:             #    placed_mine_fitness = 0.5

+4038:             if self.ship_state.lives_remaining >= 3:

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4038, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4038, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyObject_RichCompare(__pyx_t_9, __pyx_mstate_global->__pyx_int_3, Py_GE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4038, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4038, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (__pyx_t_2) {
/* … */
      goto __pyx_L46;
    }

+4039:                 placed_mine_fitness = 1.0

      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_1_0);
      __pyx_v_placed_mine_fitness = __pyx_mstate_global->__pyx_float_1_0;

 4040:             else:

+4041:                 placed_mine_fitness = mine_safe_time_fitness

    /*else*/ {
      __Pyx_INCREF(__pyx_v_mine_safe_time_fitness);
      __pyx_v_placed_mine_fitness = __pyx_v_mine_safe_time_fitness;
    }
    __pyx_L46:;

 4042:         else:

+4043:             placed_mine_fitness = 0.0

  /*else*/ {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_v_placed_mine_fitness = __pyx_mstate_global->__pyx_float_0_0;
  }
  __pyx_L45:;

 4044: 

 4045:         # debug_print(f"Fitness: {asteroid_safe_time_fitness + mine_safe_time_fitness + asteroids_fitness + sequence_length_fitness + other_ship_proximity_fitness + crash_fitness}, Ast safe time score: {asteroid_safe_time_fitness} (safe time after maneuver is {safe_time_after_maneuver_s} s, and current sim mode is {'stationary' if displacement < EPS else 'maneuver'}), asteroids score: {asteroids_fitness}, sequence length score: {sequence_length_fitness}, other ship prox score: {other_ship_proximity_fitness}")

 4046:         # self.explanation_messages.append(f"Fitness: {asteroid_safe_time_score + mine_safe_time_score + asteroids_score + sequence_length_score + displacement_score}, Ast safe time score: {asteroid_safe_time_score} (safe time after maneuver is {safe_time_after_maneuver_s} s, mine safe time score: {mine_safe_time_score}, and current sim mode is {'stationary' if displacement < EPS else 'maneuver'}), asteroids score: {asteroids_score}, sequence length score: {sequence_length_score}, displacement score: {displacement_score}, other ship prox score: {other_ship_proximity_score}")

 4047:         # debug_print(f"Fitness: {asteroid_safe_time_fitness + mine_safe_time_fitness + asteroids_fitness + sequence_length_fitness + other_ship_proximity_fitness + crash_fitness}, Ast safe time score: {asteroid_safe_time_fitness} (safe time after maneuver is {safe_time_after_maneuver_s} s, mine safe time score: {mine_safe_time_fitness}, and current sim mode is {'stationary' if displacement < EPS else 'maneuver'}), asteroids score: {asteroids_fitness}, sequence length score: {sequence_length_fitness}, other ship prox score: {other_ship_proximity_fitness}, crash_score: {crash_fitness}")

+4048:         if asteroid_safe_time_fitness < 0.1:

  __pyx_t_10 = PyObject_RichCompare(__pyx_v_asteroid_safe_time_fitness, __pyx_mstate_global->__pyx_float_0_1, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4048, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4048, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L47;
  }

+4049:             self.safety_messages.append(f"I'm dangerously close to being hit by asteroids if I stay here (Imminent collision in {next_extrapolated_asteroid_collision_time:.1f}s). Trying my hardest to maneuver out of this situation.")

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4049, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = __Pyx_PyObject_Format(__pyx_v_next_extrapolated_asteroid_collision_time, __pyx_mstate_global->__pyx_kp_u_1f); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4049, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_20[0] = __pyx_mstate_global->__pyx_kp_u_I_m_dangerously_close_to_being_h;
    __pyx_t_20[1] = __pyx_t_9;
    __pyx_t_20[2] = __pyx_mstate_global->__pyx_kp_u_s_Trying_my_hardest_to_maneuver;
    __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_20, 3, 86 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 56, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4049, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_10, __pyx_t_6); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4049, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+4050:         elif asteroid_safe_time_fitness < 0.4:

  __pyx_t_6 = PyObject_RichCompare(__pyx_v_asteroid_safe_time_fitness, __pyx_mstate_global->__pyx_float_0_4, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4050, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4050, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L47;
  }

+4051:             self.safety_messages.append(f"I'm close to being hit by asteroids if I stay here (Imminent collision in {next_extrapolated_asteroid_collision_time:.1f}s).")

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4051, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_10 = __Pyx_PyObject_Format(__pyx_v_next_extrapolated_asteroid_collision_time, __pyx_mstate_global->__pyx_kp_u_1f); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4051, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_20[0] = __pyx_mstate_global->__pyx_kp_u_I_m_close_to_being_hit_by_astero;
    __pyx_t_20[1] = __pyx_t_10;
    __pyx_t_20[2] = __pyx_mstate_global->__pyx_kp_u_s;
    __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_20, 3, 74 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 3, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4051, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_9); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4051, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4052:         elif asteroid_safe_time_fitness < 0.8:

  __pyx_t_9 = PyObject_RichCompare(__pyx_v_asteroid_safe_time_fitness, __pyx_mstate_global->__pyx_float_0_8, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4052, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4052, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__pyx_t_2) {
/* … */
  }
  __pyx_L47:;

+4053:             self.safety_messages.append(f"I'll eventually get hit by asteroids if I stay here (Imminent collision in {next_extrapolated_asteroid_collision_time:.1f}s). Keeping my eye out for a dodge maneuver.")

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4053, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_6 = __Pyx_PyObject_Format(__pyx_v_next_extrapolated_asteroid_collision_time, __pyx_mstate_global->__pyx_kp_u_1f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4053, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_20[0] = __pyx_mstate_global->__pyx_kp_u_I_ll_eventually_get_hit_by_aster;
    __pyx_t_20[1] = __pyx_t_6;
    __pyx_t_20[2] = __pyx_mstate_global->__pyx_kp_u_s_Keeping_my_eye_out_for_a_dodge;
    __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_20, 3, 75 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 44, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6));
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4053, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_9, __pyx_t_10); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4053, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 4054: 

+4055:         if mine_safe_time_fitness < 0.1:

  __pyx_t_10 = PyObject_RichCompare(__pyx_v_mine_safe_time_fitness, __pyx_mstate_global->__pyx_float_0_1, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4055, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4055, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L48;
  }

+4056:             self.safety_messages.append(f"I'm dangerously close to being kablooied by a mine (Imminent blast in {next_extrapolated_mine_collision_time:.1f}s). Trying my hardest to maneuver out of this situation.")

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4056, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = __Pyx_PyObject_Format(__pyx_v_next_extrapolated_mine_collision_time, __pyx_mstate_global->__pyx_kp_u_1f); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4056, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_20[0] = __pyx_mstate_global->__pyx_kp_u_I_m_dangerously_close_to_being_k;
    __pyx_t_20[1] = __pyx_t_9;
    __pyx_t_20[2] = __pyx_mstate_global->__pyx_kp_u_s_Trying_my_hardest_to_maneuver;
    __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_20, 3, 70 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 56, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4056, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_10, __pyx_t_6); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4056, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+4057:         elif mine_safe_time_fitness < 0.4:

  __pyx_t_6 = PyObject_RichCompare(__pyx_v_mine_safe_time_fitness, __pyx_mstate_global->__pyx_float_0_4, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4057, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4057, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L48;
  }

+4058:             self.safety_messages.append(f"I'm close to being boomed by a mine (Imminent blast in {next_extrapolated_mine_collision_time:.1f}s).")

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4058, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_10 = __Pyx_PyObject_Format(__pyx_v_next_extrapolated_mine_collision_time, __pyx_mstate_global->__pyx_kp_u_1f); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4058, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_20[0] = __pyx_mstate_global->__pyx_kp_u_I_m_close_to_being_boomed_by_a_m;
    __pyx_t_20[1] = __pyx_t_10;
    __pyx_t_20[2] = __pyx_mstate_global->__pyx_kp_u_s;
    __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_20, 3, 55 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 3, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4058, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_9); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4058, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4059:         elif mine_safe_time_fitness < 0.9:

  __pyx_t_9 = PyObject_RichCompare(__pyx_v_mine_safe_time_fitness, __pyx_mstate_global->__pyx_float_0_9, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4059, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4059, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__pyx_t_2) {
/* … */
  }
  __pyx_L48:;

+4060:             self.safety_messages.append(f"I'm within the radius of a mine (Imminent blast in {next_extrapolated_mine_collision_time:.1f}s).")

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4060, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_6 = __Pyx_PyObject_Format(__pyx_v_next_extrapolated_mine_collision_time, __pyx_mstate_global->__pyx_kp_u_1f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4060, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_20[0] = __pyx_mstate_global->__pyx_kp_u_I_m_within_the_radius_of_a_mine;
    __pyx_t_20[1] = __pyx_t_6;
    __pyx_t_20[2] = __pyx_mstate_global->__pyx_kp_u_s;
    __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_20, 3, 51 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 3, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6));
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4060, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_9, __pyx_t_10); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4060, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 4061: 

+4062:         if other_ship_proximity_fitness < 0.2:

  __pyx_t_10 = PyObject_RichCompare(__pyx_v_other_ship_proximity_fitness, __pyx_mstate_global->__pyx_float_0_2, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4062, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4062, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L49;
  }

+4063:             self.safety_messages.append("I'm dangerously close to the other ship. Get away from me!")

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4063, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_I_m_dangerously_close_to_the_oth); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4063, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+4064:         elif other_ship_proximity_fitness < 0.5:

  __pyx_t_10 = PyObject_RichCompare(__pyx_v_other_ship_proximity_fitness, __pyx_mstate_global->__pyx_float_0_5, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4064, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4064, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_2) {
/* … */
  }
  __pyx_L49:;

+4065:             self.safety_messages.append("I'm near the other ship. Being cautious.")

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4065, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_I_m_near_the_other_ship_Being_ca); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4065, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 4066: 

 4067:         # Use fuzzy "AND" by averaging the fuzzy outputs

+4068:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4068, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4068, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_2) {
/* … */
  }

+4069:             assert 0.0 <= asteroid_safe_time_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_asteroid_safe_time_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4069, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_asteroid_safe_time_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4069, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4069, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4069, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4069, __pyx_L1_error)
    #endif

+4070:             assert 0.0 <= mine_safe_time_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_mine_safe_time_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4070, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_mine_safe_time_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4070, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4070, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4070, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4070, __pyx_L1_error)
    #endif

+4071:             assert -1.0 <= asteroids_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_neg_1_0, __pyx_v_asteroids_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4071, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_asteroids_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4071, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4071, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4071, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4071, __pyx_L1_error)
    #endif

+4072:             assert 0.0 <= sequence_length_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_sequence_length_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4072, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_sequence_length_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4072, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4072, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4072, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4072, __pyx_L1_error)
    #endif

+4073:             assert 0.0 <= other_ship_proximity_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_other_ship_proximity_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4073, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_other_ship_proximity_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4073, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4073, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4073, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4073, __pyx_L1_error)
    #endif

+4074:             assert 0.0 <= crash_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_crash_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4074, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_crash_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4074, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4074, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4074, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4074, __pyx_L1_error)
    #endif

+4075:             assert 0.0 <= asteroid_aiming_cone_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_asteroid_aiming_cone_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4075, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_asteroid_aiming_cone_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4075, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4075, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4075, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4075, __pyx_L1_error)
    #endif

+4076:             assert 0.0 <= placed_mine_fitness <= 1.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_placed_mine_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4076, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_placed_mine_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4076, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4076, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4076, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4076, __pyx_L1_error)
    #endif

+4077:         fitness_breakdown = (asteroid_safe_time_fitness, mine_safe_time_fitness, asteroids_fitness, sequence_length_fitness, other_ship_proximity_fitness, crash_fitness, asteroid_aiming_cone_fitness, placed_mine_fitness, overall_safe_time_fitness)

  __pyx_t_10 = PyTuple_New(9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4077, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_INCREF(__pyx_v_asteroid_safe_time_fitness);
  __Pyx_GIVEREF(__pyx_v_asteroid_safe_time_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_asteroid_safe_time_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_mine_safe_time_fitness);
  __Pyx_GIVEREF(__pyx_v_mine_safe_time_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_mine_safe_time_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_asteroids_fitness);
  __Pyx_GIVEREF(__pyx_v_asteroids_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_v_asteroids_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_sequence_length_fitness);
  __Pyx_GIVEREF(__pyx_v_sequence_length_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 3, __pyx_v_sequence_length_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_other_ship_proximity_fitness);
  __Pyx_GIVEREF(__pyx_v_other_ship_proximity_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 4, __pyx_v_other_ship_proximity_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_crash_fitness);
  __Pyx_GIVEREF(__pyx_v_crash_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 5, __pyx_v_crash_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_asteroid_aiming_cone_fitness);
  __Pyx_GIVEREF(__pyx_v_asteroid_aiming_cone_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 6, __pyx_v_asteroid_aiming_cone_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_placed_mine_fitness);
  __Pyx_GIVEREF(__pyx_v_placed_mine_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 7, __pyx_v_placed_mine_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_overall_safe_time_fitness);
  __Pyx_GIVEREF(__pyx_v_overall_safe_time_fitness);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 8, __pyx_v_overall_safe_time_fitness) != (0)) __PYX_ERR(0, 4077, __pyx_L1_error);
  __pyx_v_fitness_breakdown = ((PyObject*)__pyx_t_10);
  __pyx_t_10 = 0;

+4078:         self.fitness_breakdown = fitness_breakdown

  if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fitness_breakdown, __pyx_v_fitness_breakdown) < 0) __PYX_ERR(0, 4078, __pyx_L1_error)

+4079:         if fitness_function_weights is not None:

  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_fitness_function_weights); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_2 = (__pyx_t_10 != Py_None);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L51;
  }

+4080:             fitness_weights = fitness_function_weights

    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_fitness_function_weights); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4080, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_v_fitness_weights = __pyx_t_10;
    __pyx_t_10 = 0;

 4081:         else:

 4082:             # It might seem counterintuitive to weigh being near a mine to be worse than dying. But the issue with being near a mine, is that it can very easily lead to losing MULTIPLE lives, because if you get hit by an asteroid, and then not have time to clear the blast radius, you'll lose two lives. So yes, being near a mine can be worse than dying!

+4083:             fitness_weights = DEFAULT_FITNESS_WEIGHTS

  /*else*/ {
    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_DEFAULT_FITNESS_WEIGHTS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4083, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_v_fitness_weights = __pyx_t_10;
    __pyx_t_10 = 0;
  }
  __pyx_L51:;

 4084:         # print(fitness_weights)

 4085:         # overall_fitness = weighted_average(fitness_breakdown, fitness_weights)

 4086:         # print(fitness_breakdown, fitness_weights)

+4087:         overall_fitness = weighted_harmonic_mean(fitness_breakdown, fitness_weights, 1.0)

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_weighted_harmonic_mean); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4087, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_9, __pyx_v_fitness_breakdown, __pyx_v_fitness_weights, __pyx_mstate_global->__pyx_float_1_0};
    __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4087, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }
  __pyx_v_overall_fitness = __pyx_t_10;
  __pyx_t_10 = 0;

+4088:         assert 0.0 <= overall_fitness <= 1.0 or asteroids_fitness < 0.0, f"Overall fitness of {overall_fitness} is out of range! Fitness breakdown: {fitness_breakdown}"  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_10 = PyObject_RichCompare(__pyx_mstate_global->__pyx_float_0_0, __pyx_v_overall_fitness, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4088, __pyx_L1_error)
    if (__Pyx_PyObject_IsTrue(__pyx_t_10)) {
      __Pyx_DECREF(__pyx_t_10);
      __pyx_t_10 = PyObject_RichCompare(__pyx_v_overall_fitness, __pyx_mstate_global->__pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4088, __pyx_L1_error)
    }
    __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4088, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (!__pyx_t_17) {
    } else {
      __pyx_t_2 = __pyx_t_17;
      goto __pyx_L52_bool_binop_done;
    }
    __pyx_t_10 = PyObject_RichCompare(__pyx_v_asteroids_fitness, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4088, __pyx_L1_error)
    __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4088, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_2 = __pyx_t_17;
    __pyx_L52_bool_binop_done:;
    if (unlikely(!__pyx_t_2)) {
      __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_overall_fitness, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4088, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_fitness_breakdown, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4088, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_22[0] = __pyx_mstate_global->__pyx_kp_u_Overall_fitness_of;
      __pyx_t_22[1] = __pyx_t_10;
      __pyx_t_22[2] = __pyx_mstate_global->__pyx_kp_u_is_out_of_range_Fitness_breakdo;
      __pyx_t_22[3] = __pyx_t_6;
      __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_22, 4, 19 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 37 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6));
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4088, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_9, 0, 0);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __PYX_ERR(0, 4088, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 4088, __pyx_L1_error)
  #endif

 4089:         # self.explanation_messages.append(f"Chose the sim with fitnesses: {overall_fitness=}, {asteroid_safe_time_fitness=}, {mine_safe_time_fitness=}, {asteroids_fitness=}, {sequence_length_fitness=}, {other_ship_proximity_fitness=}, {crash_fitness=}, {asteroid_aiming_cone_fitness=}")

+4090:         if overall_fitness > 0.9:

  __pyx_t_9 = PyObject_RichCompare(__pyx_v_overall_fitness, __pyx_mstate_global->__pyx_float_0_9, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4090, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4090, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__pyx_t_2) {
/* … */
  }

+4091:             self.safety_messages.append("I'm safe and chilling")

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_safety_messages); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4091, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_I_m_safe_and_chilling); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 4091, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 4092:         #else:

 4093:         #    pass

 4094:             # self.safety_messages.append(f"Stationary sim had fitnesses: {overall_fitness=}, {asteroid_safe_time_fitness=}, {mine_safe_time_fitness=}, {asteroids_fitness=}, {sequence_length_fitness=}, {other_ship_proximity_fitness=}, {crash_fitness=}, {asteroid_aiming_cone_fitness=}")

 4095:         # The overall_fitness is the fuzzy output. There's no need to defuzzify it since we're using this as a fitness value to rank the actions and future states

+4096:         return overall_fitness

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_overall_fitness);
  __pyx_r = __pyx_v_overall_fitness;
  goto __pyx_L0;

 4097: 

+4098:     def get_fitness_breakdown(self) -> tuple[float, float, float, float, float, float, float, float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_43get_fitness_breakdown(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_43get_fitness_breakdown = {"get_fitness_breakdown", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_43get_fitness_breakdown, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_43get_fitness_breakdown(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_fitness_breakdown (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4098, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4098, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_fitness_breakdown", 0) < 0) __PYX_ERR(0, 4098, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_fitness_breakdown", 1, 1, 1, i); __PYX_ERR(0, 4098, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4098, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_fitness_breakdown", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4098, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness_breakdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_42get_fitness_breakdown(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_42get_fitness_breakdown(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_fitness_breakdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4098, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float_float_float_fl) < 0) __PYX_ERR(0, 4098, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_43get_fitness_breakdown, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_fitness_breakdown, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[167])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4098, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_fitness_breakdown, __pyx_t_2) < 0) __PYX_ERR(0, 4098, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_ctuple_2b55ad__double__and_double__and_double__and_double__an__etc {
  double f0;
  double f1;
  double f2;
  double f3;
  double f4;
  double f5;
  double f6;
  double f7;
  double f8;
};

 4099:         # This is used to get the individual fitnesses before they got aggregated into the one fitness that was returned.

+4100:         assert self.fitness_breakdown is not None

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = (__pyx_t_1 != Py_None);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 4100, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 4100, __pyx_L1_error)
  #endif

+4101:         return self.fitness_breakdown

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 4102: 

+4103:     def find_extreme_shooting_angle_error(self, asteroid_list: list[Target], threshold: float, mode: str = 'largest_below') -> Target | None:

/* Python wrapper */
static struct __pyx_obj_14neo_controller_Target *__pyx_pw_14neo_controller_6Matrix_45find_extreme_shooting_angle_error(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_45find_extreme_shooting_angle_error = {"find_extreme_shooting_angle_error", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_45find_extreme_shooting_angle_error, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static struct __pyx_obj_14neo_controller_Target *__pyx_pw_14neo_controller_6Matrix_45find_extreme_shooting_angle_error(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_asteroid_list = 0;
  double __pyx_v_threshold;
  PyObject *__pyx_v_mode = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  struct __pyx_obj_14neo_controller_Target *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("find_extreme_shooting_angle_error (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_asteroid_list,&__pyx_mstate_global->__pyx_n_u_threshold,&__pyx_mstate_global->__pyx_n_u_mode,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4103, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4103, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4103, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4103, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4103, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "find_extreme_shooting_angle_error", 0) < 0) __PYX_ERR(0, 4103, __pyx_L3_error)
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_n_u_largest_below)));
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("find_extreme_shooting_angle_error", 0, 3, 4, i); __PYX_ERR(0, 4103, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4103, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4103, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4103, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4103, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_n_u_largest_below)));
    }
    __pyx_v_self = values[0];
    __pyx_v_asteroid_list = ((PyObject*)values[1]);
    __pyx_v_threshold = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_threshold == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4103, __pyx_L3_error)
    __pyx_v_mode = ((PyObject*)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("find_extreme_shooting_angle_error", 0, 3, 4, __pyx_nargs); __PYX_ERR(0, 4103, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.find_extreme_shooting_angle_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroid_list), (&PyList_Type), 0, "asteroid_list", 2))) __PYX_ERR(0, 4103, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mode), (&PyUnicode_Type), 0, "mode", 2))) __PYX_ERR(0, 4103, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_44find_extreme_shooting_angle_error(__pyx_self, __pyx_v_self, __pyx_v_asteroid_list, __pyx_v_threshold, __pyx_v_mode);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_14neo_controller_Target *__pyx_pf_14neo_controller_6Matrix_44find_extreme_shooting_angle_error(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, PyObject *__pyx_v_asteroid_list, double __pyx_v_threshold, PyObject *__pyx_v_mode) {
  PyObject *__pyx_v_shooting_angles = NULL;
  PyObject *__pyx_v_idx = NULL;
  PyObject *__pyx_9genexpr33__pyx_v_d = NULL;
  struct __pyx_obj_14neo_controller_Target *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.Matrix.find_extreme_shooting_angle_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_shooting_angles);
  __Pyx_XDECREF(__pyx_v_idx);
  __Pyx_XDECREF(__pyx_9genexpr33__pyx_v_d);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroid_list, __pyx_mstate_global->__pyx_kp_u_list_Target) < 0) __PYX_ERR(0, 4103, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_threshold, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 4103, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_mode, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 4103, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_Target_None) < 0) __PYX_ERR(0, 4103, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_45find_extreme_shooting_angle_error, 0, __pyx_mstate_global->__pyx_n_u_Matrix_find_extreme_shooting_ang, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[168])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[92]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_find_extreme_shooting_angle_erro, __pyx_t_3) < 0) __PYX_ERR(0, 4103, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[92] = PyTuple_Pack(1, ((PyObject*)__pyx_mstate_global->__pyx_n_u_largest_below)); if (unlikely(!__pyx_mstate_global->__pyx_tuple[92])) __PYX_ERR(0, 4103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[92]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[92]);

 4104:         # This takes in a list of targets sorted by the shooting angle required, and it'll let you find the next target above or below a given target

 4105:         # This is useful if, say you want to shoot at a target, but the ship can't spin that far before you're able to shoot again, so you can pick a target to shoot along the way. I know this was a bad explanation but hopefully you get the idea.

 4106:         # Extract the shooting_angle_error_deg values

+4107:         shooting_angles = [d.shooting_angle_error_deg for d in asteroid_list]

  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4107, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __pyx_v_asteroid_list; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4107, __pyx_L5_error)
        #endif
        if (__pyx_t_3 >= __pyx_temp) break;
      }
      __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3);
      ++__pyx_t_3;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4107, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_9genexpr33__pyx_v_d, __pyx_t_4);
      __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr33__pyx_v_d, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4107, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 4107, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_9genexpr33__pyx_v_d); __pyx_9genexpr33__pyx_v_d = 0;
    goto __pyx_L9_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_9genexpr33__pyx_v_d); __pyx_9genexpr33__pyx_v_d = 0;
    goto __pyx_L1_error;
    __pyx_L9_exit_scope:;
  } /* exit inner scope */
  __pyx_v_shooting_angles = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 4108: 

+4109:         if mode == 'largest_below':

  __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_largest_below, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4109, __pyx_L1_error)
  if (__pyx_t_5) {
/* … */
    goto __pyx_L10;
  }

 4110:             # Find the index where threshold would be inserted

 4111:             #a = time.perf_counter()

+4112:             idx = bisect.bisect_left(shooting_angles, threshold)

    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bisect); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bisect_left); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_threshold); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_shooting_angles, __pyx_t_4};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4112, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_idx = __pyx_t_1;
    __pyx_t_1 = 0;

 4113:             #b = time.perf_counter()

 4114:             # Adjust the index to get the largest value below the threshold

+4115:             if idx > 0:

    __pyx_t_1 = PyObject_RichCompare(__pyx_v_idx, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4115, __pyx_L1_error)
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4115, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_5) {
/* … */
      goto __pyx_L11;
    }

+4116:                 idx -= 1

      __pyx_t_1 = __Pyx_PyLong_SubtractObjC(__pyx_v_idx, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4116, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF_SET(__pyx_v_idx, __pyx_t_1);
      __pyx_t_1 = 0;

 4117:             else:

+4118:                 return None  # All values are greater than or equal to the threshold

    /*else*/ {
      __Pyx_XDECREF((PyObject *)__pyx_r);
      __pyx_r = ((struct __pyx_obj_14neo_controller_Target *)Py_None); __Pyx_INCREF(Py_None);
      goto __pyx_L0;
    }
    __pyx_L11:;

+4119:         elif mode == 'smallest_above':

  __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_smallest_above, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4119, __pyx_L1_error)
  if (likely(__pyx_t_5)) {
/* … */
    goto __pyx_L10;
  }

 4120:             # Find the index where threshold would be inserted

 4121:             #a = time.perf_counter()

+4122:             idx = bisect.bisect_right(shooting_angles, threshold)

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bisect); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bisect_right); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_threshold); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_shooting_angles, __pyx_t_4};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4122, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_idx = __pyx_t_1;
    __pyx_t_1 = 0;

 4123:             #b = time.perf_counter()

 4124:             # Check if all values are smaller than the threshold

+4125:             if idx >= len(shooting_angles):

    __pyx_t_3 = __Pyx_PyList_GET_SIZE(__pyx_v_shooting_angles); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4125, __pyx_L1_error)
    __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4125, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyObject_RichCompare(__pyx_v_idx, __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4125, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4125, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_5) {
/* … */
    }

+4126:                 return None

      __Pyx_XDECREF((PyObject *)__pyx_r);
      __pyx_r = ((struct __pyx_obj_14neo_controller_Target *)Py_None); __Pyx_INCREF(Py_None);
      goto __pyx_L0;

 4127:         else:

+4128:             raise ValueError("Invalid mode. Choose 'largest_below' or 'smallest_above'")

  /*else*/ {
    __pyx_t_1 = NULL;
    __Pyx_INCREF(__pyx_builtin_ValueError);
    __pyx_t_4 = __pyx_builtin_ValueError; 
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_mstate_global->__pyx_kp_u_Invalid_mode_Choose_largest_belo};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4128, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 4128, __pyx_L1_error)
  }
  __pyx_L10:;

 4129:         #print(f"Time taken to bisect: {b - a}")

 4130:         # Return the corresponding dictionary

+4131:         return asteroid_list[idx]

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_asteroid_list, __pyx_v_idx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_14neo_controller_Target))))) __PYX_ERR(0, 4131, __pyx_L1_error)
  __pyx_r = ((struct __pyx_obj_14neo_controller_Target *)__pyx_t_2);
  __pyx_t_2 = 0;
  goto __pyx_L0;

 4132: 

+4133:     def target_selection(self) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_47target_selection(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_47target_selection = {"target_selection", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_47target_selection, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_47target_selection(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("target_selection (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4133, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4133, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "target_selection", 0) < 0) __PYX_ERR(0, 4133, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("target_selection", 1, 1, 1, i); __PYX_ERR(0, 4133, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4133, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("target_selection", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4133, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_46target_selection(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
static PyObject *__pyx_pf_14neo_controller_6Matrix_46target_selection(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *__pyx_cur_scope;
  PyObject *__pyx_v_simulate_shooting_at_target = 0;
  PyObject *__pyx_v_target_asteroids_list = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_dummy_ship_state = NULL;
  PyObject *__pyx_v_timesteps_until_can_fire = 0;
  int __pyx_v_most_imminent_asteroid_exists;
  int __pyx_v_asteroids_still_exist;
  PyObject *__pyx_v_asteroid = NULL;
  PyObject *__pyx_v_best_feasible_unwrapped_target = 0;
  int __pyx_v_asteroid_will_get_hit_by_my_mine;
  int __pyx_v_asteroid_will_get_hit_by_their_mine;
  PyObject *__pyx_v_m = NULL;
  PyObject *__pyx_v_asteroid_when_mine_explodes = NULL;
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  PyObject *__pyx_v_separation = NULL;
  PyObject *__pyx_v_unwrapped_asteroids = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_feasible = NULL;
  PyObject *__pyx_v_shooting_angle_error_deg = NULL;
  PyObject *__pyx_v_aiming_timesteps_required = NULL;
  PyObject *__pyx_v_interception_time_s = NULL;
  PyObject *__pyx_v_intercept_x = NULL;
  PyObject *__pyx_v_intercept_y = NULL;
  PyObject *__pyx_v_asteroid_dist_during_interception = NULL;
  PyObject *__pyx_v_imminent_collision_time_s = NULL;
  PyObject *__pyx_v_turn_angle_deg_until_can_fire = NULL;
  PyObject *__pyx_v_actual_asteroid_hit = NULL;
  PyObject *__pyx_v_aiming_move_sequence = 0;
  PyObject *__pyx_v_sorted_imminent_targets = NULL;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_v_candidate_target = NULL;
  PyObject *__pyx_v_most_imminent_asteroid_aiming_timesteps = NULL;
  PyObject *__pyx_v_most_imminent_asteroid = NULL;
  PyObject *__pyx_v_most_imminent_asteroid_shooting_angle_error_deg = NULL;
  PyObject *__pyx_v_most_imminent_asteroid_interception_time_s = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_target_asteroid = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_target_asteroid_shooting_angle_error_deg = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_target_asteroid_interception_time_s = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_target_asteroid_turning_timesteps = NULL;
  PyObject *__pyx_v_timesteps_until_bullet_hit_asteroid = NULL;
  PyObject *__pyx_v_ship_state_after_aiming = NULL;
  PyObject *__pyx_v_len_aiming_move_sequence = NULL;
  PyObject *__pyx_v_actual_asteroid_hit_when_firing = NULL;
  PyObject *__pyx_v_sorted_targets = NULL;
  PyObject *__pyx_v_target = NULL;
  PyObject *__pyx_v_confirmed_target = NULL;
  PyObject *__pyx_v_least_shot_delay_asteroid = NULL;
  PyObject *__pyx_v_least_shot_delay_asteroid_shooting_angle_error_deg = NULL;
  PyObject *__pyx_v_least_shot_delay_asteroid_interception_time_s = NULL;
  PyObject *__pyx_v_least_shot_delay_asteroid_aiming_timesteps = NULL;
  PyObject *__pyx_v_turn_direction = NULL;
  double __pyx_v_idle_thrust;
  PyObject *__pyx_v_sim_complete_without_crash = NULL;
  PyObject *__pyx_v_actual_asteroid_hit_at_present_time = NULL;
  PyObject *__pyx_v_actual_asteroid_hit_at_present_time_for_plotting = NULL;
  PyObject *__pyx_v_future_ts_backup = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *)__pyx_tp_new_14neo_controller___pyx_scope_struct_13_target_selection(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_13_target_selection, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 4133, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_self = __pyx_v_self;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_24);
  __Pyx_XDECREF(__pyx_t_25);
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_simulate_shooting_at_target);
  __Pyx_XDECREF(__pyx_v_target_asteroids_list);
  __Pyx_XDECREF((PyObject *)__pyx_v_dummy_ship_state);
  __Pyx_XDECREF(__pyx_v_timesteps_until_can_fire);
  __Pyx_XDECREF(__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_v_best_feasible_unwrapped_target);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XDECREF(__pyx_v_asteroid_when_mine_explodes);
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_separation);
  __Pyx_XDECREF(__pyx_v_unwrapped_asteroids);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_feasible);
  __Pyx_XDECREF(__pyx_v_shooting_angle_error_deg);
  __Pyx_XDECREF(__pyx_v_aiming_timesteps_required);
  __Pyx_XDECREF(__pyx_v_interception_time_s);
  __Pyx_XDECREF(__pyx_v_intercept_x);
  __Pyx_XDECREF(__pyx_v_intercept_y);
  __Pyx_XDECREF(__pyx_v_asteroid_dist_during_interception);
  __Pyx_XDECREF(__pyx_v_imminent_collision_time_s);
  __Pyx_XDECREF(__pyx_v_turn_angle_deg_until_can_fire);
  __Pyx_XDECREF(__pyx_v_actual_asteroid_hit);
  __Pyx_XDECREF(__pyx_v_aiming_move_sequence);
  __Pyx_XDECREF(__pyx_v_sorted_imminent_targets);
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XDECREF(__pyx_v_candidate_target);
  __Pyx_XDECREF(__pyx_v_most_imminent_asteroid_aiming_timesteps);
  __Pyx_XDECREF(__pyx_v_most_imminent_asteroid);
  __Pyx_XDECREF(__pyx_v_most_imminent_asteroid_shooting_angle_error_deg);
  __Pyx_XDECREF(__pyx_v_most_imminent_asteroid_interception_time_s);
  __Pyx_XDECREF(__pyx_v_target_asteroid);
  __Pyx_XDECREF(__pyx_v_target_asteroid_shooting_angle_error_deg);
  __Pyx_XDECREF(__pyx_v_target_asteroid_interception_time_s);
  __Pyx_XDECREF(__pyx_v_target_asteroid_turning_timesteps);
  __Pyx_XDECREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
  __Pyx_XDECREF(__pyx_v_ship_state_after_aiming);
  __Pyx_XDECREF(__pyx_v_len_aiming_move_sequence);
  __Pyx_XDECREF(__pyx_v_actual_asteroid_hit_when_firing);
  __Pyx_XDECREF(__pyx_v_sorted_targets);
  __Pyx_XDECREF(__pyx_v_target);
  __Pyx_XDECREF(__pyx_v_confirmed_target);
  __Pyx_XDECREF(__pyx_v_least_shot_delay_asteroid);
  __Pyx_XDECREF(__pyx_v_least_shot_delay_asteroid_shooting_angle_error_deg);
  __Pyx_XDECREF(__pyx_v_least_shot_delay_asteroid_interception_time_s);
  __Pyx_XDECREF(__pyx_v_least_shot_delay_asteroid_aiming_timesteps);
  __Pyx_XDECREF(__pyx_v_turn_direction);
  __Pyx_XDECREF(__pyx_v_sim_complete_without_crash);
  __Pyx_XDECREF(__pyx_v_actual_asteroid_hit_at_present_time);
  __Pyx_XDECREF(__pyx_v_actual_asteroid_hit_at_present_time_for_plotting);
  __Pyx_XDECREF(__pyx_v_future_ts_backup);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4133, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_47target_selection, 0, __pyx_mstate_global->__pyx_n_u_Matrix_target_selection, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[169])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_target_selection, __pyx_t_2) < 0) __PYX_ERR(0, 4133, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection {
  PyObject_HEAD
  double __pyx_v_frontrun_score_multiplier;
  PyObject *__pyx_v_self;
};

 4134:         # The job of this method is to calculate how to hit each asteroid, and then pick the best one to try to target

+4135:         def simulate_shooting_at_target(target_asteroid_original: Asteroid, target_asteroid_shooting_angle_error_deg: float, target_asteroid_interception_time_s: float, target_asteroid_turning_timesteps: int) -> tuple[Optional[Asteroid], list[Action], Asteroid, float, float, int, Optional[int], Ship]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_1simulate_shooting_at_target(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target, "\n            Uses the bullet sim to check whether we'll hit a target, and which target we end up hitting since we might hit an asteroid in front of our intended target\n            target_asteroid_original: Our target asteroid\n            target_asteroid_shooting_angle_error_deg: The amount in degrees the ship needs to turn to be able to shoot the target\n            target_asteroid_interception_time_s: The time in seconds between firing and hitting the center of the target. The turning time is not included!\n            target_asteroid_turning_timesteps: The number of timesteps we need to turn for before shooting. Well, we might require fewer timesteps than this, but this is the prescribed number of timesteps we must wait out until we shoot, to be able to hit our target.\n            ");
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_16target_selection_1simulate_shooting_at_target = {"simulate_shooting_at_target", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_16target_selection_1simulate_shooting_at_target, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target};
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_1simulate_shooting_at_target(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_target_asteroid_original = 0;
  double __pyx_v_target_asteroid_shooting_angle_error_deg;
  double __pyx_v_target_asteroid_interception_time_s;
  PyObject *__pyx_v_target_asteroid_turning_timesteps = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("simulate_shooting_at_target (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_target_asteroid_original,&__pyx_mstate_global->__pyx_n_u_target_asteroid_shooting_angle_e,&__pyx_mstate_global->__pyx_n_u_target_asteroid_interception_tim,&__pyx_mstate_global->__pyx_n_u_target_asteroid_turning_timestep,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4135, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4135, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4135, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4135, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4135, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "simulate_shooting_at_target", 0) < 0) __PYX_ERR(0, 4135, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("simulate_shooting_at_target", 1, 4, 4, i); __PYX_ERR(0, 4135, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4135, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4135, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4135, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4135, __pyx_L3_error)
    }
    __pyx_v_target_asteroid_original = ((struct __pyx_obj_14neo_controller_Asteroid *)values[0]);
    __pyx_v_target_asteroid_shooting_angle_error_deg = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_target_asteroid_shooting_angle_error_deg == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4135, __pyx_L3_error)
    __pyx_v_target_asteroid_interception_time_s = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_target_asteroid_interception_time_s == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4135, __pyx_L3_error)
    __pyx_v_target_asteroid_turning_timesteps = ((PyObject*)values[3]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("simulate_shooting_at_target", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 4135, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.simulate_shooting_at_target", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_target_asteroid_original), __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid, 0, "target_asteroid_original", 0))) __PYX_ERR(0, 4135, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_target_asteroid_turning_timesteps), (&PyLong_Type), 0, "target_asteroid_turning_timesteps", 2))) __PYX_ERR(0, 4135, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target(__pyx_self, __pyx_v_target_asteroid_original, __pyx_v_target_asteroid_shooting_angle_error_deg, __pyx_v_target_asteroid_interception_time_s, __pyx_v_target_asteroid_turning_timesteps);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target(PyObject *__pyx_self, struct __pyx_obj_14neo_controller_Asteroid *__pyx_v_target_asteroid_original, double __pyx_v_target_asteroid_shooting_angle_error_deg, double __pyx_v_target_asteroid_interception_time_s, PyObject *__pyx_v_target_asteroid_turning_timesteps) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *__pyx_outer_scope;
  PyObject *__pyx_v_aiming_move_sequence = NULL;
  PyObject *__pyx_v_timesteps_until_can_fire = NULL;
  PyObject *__pyx_v_asteroid_advance_timesteps = NULL;
  PyObject *__pyx_v_target_asteroid = NULL;
  PyObject *__pyx_v_ship_state_after_aiming = NULL;
  PyObject *__pyx_v_actual_asteroid_hit = NULL;
  PyObject *__pyx_v_timesteps_until_bullet_hit_asteroid = NULL;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  CYTHON_UNUSED PyObject *__pyx_9genexpr34__pyx_v__ = NULL;
  CYTHON_UNUSED PyObject *__pyx_9genexpr35__pyx_v__ = NULL;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.simulate_shooting_at_target", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_aiming_move_sequence);
  __Pyx_XDECREF(__pyx_v_timesteps_until_can_fire);
  __Pyx_XDECREF(__pyx_v_asteroid_advance_timesteps);
  __Pyx_XDECREF(__pyx_v_target_asteroid);
  __Pyx_XDECREF(__pyx_v_ship_state_after_aiming);
  __Pyx_XDECREF(__pyx_v_actual_asteroid_hit);
  __Pyx_XDECREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XDECREF(__pyx_9genexpr34__pyx_v__);
  __Pyx_XDECREF(__pyx_9genexpr35__pyx_v__);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_target_asteroid_original, __pyx_mstate_global->__pyx_n_u_Asteroid_2) < 0) __PYX_ERR(0, 4135, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_target_asteroid_shooting_angle_e, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 4135, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_target_asteroid_interception_tim, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 4135, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_target_asteroid_turning_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 4135, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_Optional_Asteroid_list_Act) < 0) __PYX_ERR(0, 4135, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_16target_selection_1simulate_shooting_at_target, 0, __pyx_mstate_global->__pyx_n_u_Matrix_target_selection_locals_s, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_simulate_shooting_at_target = __pyx_t_2;
  __pyx_t_2 = 0;

 4136:             '''

 4137:             Uses the bullet sim to check whether we'll hit a target, and which target we end up hitting since we might hit an asteroid in front of our intended target

 4138:             target_asteroid_original: Our target asteroid

 4139:             target_asteroid_shooting_angle_error_deg: The amount in degrees the ship needs to turn to be able to shoot the target

 4140:             target_asteroid_interception_time_s: The time in seconds between firing and hitting the center of the target. The turning time is not included!

 4141:             target_asteroid_turning_timesteps: The number of timesteps we need to turn for before shooting. Well, we might require fewer timesteps than this, but this is the prescribed number of timesteps we must wait out until we shoot, to be able to hit our target.

 4142:             '''

 4143: 

 4144:             # Just because we're lined up for a shot doesn't mean our shot will hit, unfortunately.

 4145:             # Bullets and asteroids travel in discrete timesteps, and it's possible for the bullet to miss the asteroid hitbox between timesteps, where the interception would have occurred on an intermediate timestep.

 4146:             # This is unavoidable, and we just have to choose targets that don't do this.

 4147:             # If the asteroids are moving slow enough, this should be rare, but especially if small asteroids are moving very quickly, this issue is common.

 4148:             # A simulation will easily show whether this will happen or not

 4149:             # debug_print(f"The last timestep fired is {self.last_timestep_fired}")

+4150:             aiming_move_sequence = self.get_rotate_heading_move_sequence(target_asteroid_shooting_angle_error_deg)

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4150, __pyx_L1_error) }
  __pyx_t_2 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_target_asteroid_shooting_angle_error_deg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_rotate_heading_move_sequence, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4150, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_aiming_move_sequence = __pyx_t_1;
  __pyx_t_1 = 0;

 4151:             #timesteps_until_can_fire: int

+4152:             if self.fire_first_timestep:

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4152, __pyx_L1_error) }
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_first_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4152, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_5) {
/* … */
    goto __pyx_L3;
  }

+4153:                 timesteps_until_can_fire = max(0, int(FIRE_COOLDOWN_TS) - len(aiming_move_sequence))

    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_FIRE_COOLDOWN_TS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4153, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4153, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = PyObject_Length(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4153, __pyx_L1_error)
    __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4153, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Subtract(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4153, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_7 = 0;
    __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4153, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4153, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4153, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_5) {
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_1 = __pyx_t_2;
    } else {
      __pyx_t_8 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4153, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_1 = __pyx_t_8;
      __pyx_t_8 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __pyx_t_1;
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (!(likely(PyLong_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_2))) __PYX_ERR(0, 4153, __pyx_L1_error)
    __pyx_v_timesteps_until_can_fire = ((PyObject*)__pyx_t_2);
    __pyx_t_2 = 0;

 4154:             else:

+4155:                 timesteps_until_can_fire = max(0, int(FIRE_COOLDOWN_TS) - int(int(self.initial_timestep) + int(self.future_timesteps) + len(aiming_move_sequence) - int(self.last_timestep_fired)))

  /*else*/ {
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_FIRE_COOLDOWN_TS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_PyNumber_Int(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4155, __pyx_L1_error) }
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_8 = __Pyx_PyNumber_Int(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4155, __pyx_L1_error) }
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Add(__pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = PyObject_Length(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4155, __pyx_L1_error)
    __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4155, __pyx_L1_error) }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Subtract(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Subtract(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_7 = 0;
    __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4155, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_5) {
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_2 = __pyx_t_3;
    } else {
      __pyx_t_8 = __Pyx_PyLong_From_long(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4155, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (!(likely(PyLong_CheckExact(__pyx_t_8)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_8))) __PYX_ERR(0, 4155, __pyx_L1_error)
      __pyx_t_2 = __pyx_t_8;
      __pyx_t_8 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __pyx_t_2;
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_timesteps_until_can_fire = ((PyObject*)__pyx_t_3);
    __pyx_t_3 = 0;
  }
  __pyx_L3:;

 4156:             # debug_print(f'aiming move seq before append, and ts until can fire is {timesteps_until_can_fire}')

 4157:             # debug_print(aiming_move_sequence)

 4158:             #aiming_move_sequence.extend([cast(Action, {'thrust': 0.0, 'turn_rate': 0.0, 'fire': False})]*timesteps_until_can_fire)

+4159:             aiming_move_sequence.extend([Action(thrust=0.0, turn_rate=0.0, fire=False) for _ in range(timesteps_until_can_fire)])

  __pyx_t_2 = __pyx_v_aiming_move_sequence;
  __Pyx_INCREF(__pyx_t_2);
  { /* enter inner scope */
    __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4159, __pyx_L6_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = NULL;
    __Pyx_INCREF(__pyx_builtin_range);
    __pyx_t_10 = __pyx_builtin_range; 
    __pyx_t_4 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_timesteps_until_can_fire};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4159, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
      __pyx_t_10 = __pyx_t_1; __Pyx_INCREF(__pyx_t_10);
      __pyx_t_6 = 0;
      __pyx_t_11 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4159, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4159, __pyx_L6_error)
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    for (;;) {
      if (likely(!__pyx_t_11)) {
        if (likely(PyList_CheckExact(__pyx_t_10))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4159, __pyx_L6_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4159, __pyx_L6_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_6));
          #else
          __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4159, __pyx_L6_error)
      } else {
        __pyx_t_1 = __pyx_t_11(__pyx_t_10);
        if (unlikely(!__pyx_t_1)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4159, __pyx_L6_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_1);
      if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 4159, __pyx_L6_error)
      __Pyx_XDECREF_SET(__pyx_9genexpr34__pyx_v__, ((PyObject*)__pyx_t_1));
      __pyx_t_1 = 0;
      __pyx_t_9 = NULL;
      __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
      __pyx_t_12 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
      __pyx_t_4 = 1;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_9, NULL};
        __pyx_t_13 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4159, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_13);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_13, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4159, __pyx_L6_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_13, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4159, __pyx_L6_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, Py_False, __pyx_t_13, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 4159, __pyx_L6_error)
        __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_12, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_13);
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4159, __pyx_L6_error)
        __Pyx_GOTREF((PyObject *)__pyx_t_1);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_8, (PyObject*)__pyx_t_1))) __PYX_ERR(0, 4159, __pyx_L6_error)
      __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;
    }
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_9genexpr34__pyx_v__); __pyx_9genexpr34__pyx_v__ = 0;
    goto __pyx_L10_exit_scope;
    __pyx_L6_error:;
    __Pyx_XDECREF(__pyx_9genexpr34__pyx_v__); __pyx_9genexpr34__pyx_v__ = 0;
    goto __pyx_L1_error;
    __pyx_L10_exit_scope:;
  } /* exit inner scope */
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_8};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4159, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 4160:             # debug_print('aiming move seq after append')

 4161:             # debug_print(aiming_move_sequence)

+4162:             asteroid_advance_timesteps = len(aiming_move_sequence)

  __pyx_t_6 = PyObject_Length(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4162, __pyx_L1_error)
  __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_asteroid_advance_timesteps = __pyx_t_3;
  __pyx_t_3 = 0;

 4163:             # debug_print(f"Asteroid advanced timesteps: {asteroid_advance_timesteps}")

 4164:             # debug_print(f"Targetting turning timesteps: {target_asteroid_turning_timesteps}")

+4165:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4165, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_5) {
/* … */
  }

+4166:                 assert asteroid_advance_timesteps <= target_asteroid_turning_timesteps or target_asteroid_turning_timesteps == 0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_asteroid_advance_timesteps, __pyx_v_target_asteroid_turning_timesteps, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4166, __pyx_L1_error)
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4166, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (!__pyx_t_14) {
      } else {
        __pyx_t_5 = __pyx_t_14;
        goto __pyx_L12_bool_binop_done;
      }
      __pyx_t_14 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_target_asteroid_turning_timesteps, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4166, __pyx_L1_error)
      __pyx_t_5 = __pyx_t_14;
      __pyx_L12_bool_binop_done:;
      if (unlikely(!__pyx_t_5)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4166, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4166, __pyx_L1_error)
    #endif

+4167:             if asteroid_advance_timesteps < target_asteroid_turning_timesteps:

  __pyx_t_3 = PyObject_RichCompare(__pyx_v_asteroid_advance_timesteps, __pyx_v_target_asteroid_turning_timesteps, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4167, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4167, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_5) {
/* … */
  }

 4168:                 # We're given a budget of target_asteroid_turning_timesteps timesteps to turn, however we find that the turn actually required fewer timesteps than that. We still need to wait the full number, so we just pad with null actions to wait out the time. This case should be super rare.

 4169:                 # debug_print(f"asteroid_advance_timesteps {asteroid_advance_timesteps} < target_asteroid_turning_timesteps {target_asteroid_turning_timesteps}")

 4170:                 #aiming_move_sequence.extend([cast(Action, {'thrust': 0.0, 'turn_rate': 0.0, 'fire': False})]*(target_asteroid_turning_timesteps - asteroid_advance_timesteps))

+4171:                 aiming_move_sequence.extend([Action(thrust=0.0, turn_rate=0.0, fire=False) for _ in range(target_asteroid_turning_timesteps - asteroid_advance_timesteps)])

    __pyx_t_8 = __pyx_v_aiming_move_sequence;
    __Pyx_INCREF(__pyx_t_8);
    { /* enter inner scope */
      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4171, __pyx_L17_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_1 = NULL;
      __Pyx_INCREF(__pyx_builtin_range);
      __pyx_t_12 = __pyx_builtin_range; 
      __pyx_t_13 = PyNumber_Subtract(__pyx_v_target_asteroid_turning_timesteps, __pyx_v_asteroid_advance_timesteps); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4171, __pyx_L17_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_4 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_13};
        __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4171, __pyx_L17_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      if (likely(PyList_CheckExact(__pyx_t_10)) || PyTuple_CheckExact(__pyx_t_10)) {
        __pyx_t_12 = __pyx_t_10; __Pyx_INCREF(__pyx_t_12);
        __pyx_t_6 = 0;
        __pyx_t_11 = NULL;
      } else {
        __pyx_t_6 = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4171, __pyx_L17_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4171, __pyx_L17_error)
      }
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      for (;;) {
        if (likely(!__pyx_t_11)) {
          if (likely(PyList_CheckExact(__pyx_t_12))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_12);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4171, __pyx_L17_error)
              #endif
              if (__pyx_t_6 >= __pyx_temp) break;
            }
            __pyx_t_10 = __Pyx_PyList_GetItemRef(__pyx_t_12, __pyx_t_6);
            ++__pyx_t_6;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_12);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4171, __pyx_L17_error)
              #endif
              if (__pyx_t_6 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_10 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_12, __pyx_t_6));
            #else
            __pyx_t_10 = __Pyx_PySequence_ITEM(__pyx_t_12, __pyx_t_6);
            #endif
            ++__pyx_t_6;
          }
          if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4171, __pyx_L17_error)
        } else {
          __pyx_t_10 = __pyx_t_11(__pyx_t_12);
          if (unlikely(!__pyx_t_10)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4171, __pyx_L17_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_XDECREF_SET(__pyx_9genexpr35__pyx_v__, __pyx_t_10);
        __pyx_t_10 = 0;
        __pyx_t_13 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
        __pyx_t_1 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
        __pyx_t_4 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_13, NULL};
          __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4171, __pyx_L17_error)
          __Pyx_GOTREF(__pyx_t_9);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_9, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4171, __pyx_L17_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_9, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4171, __pyx_L17_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, Py_False, __pyx_t_9, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 4171, __pyx_L17_error)
          __pyx_t_10 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_1, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4171, __pyx_L17_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_10);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_10))) __PYX_ERR(0, 4171, __pyx_L17_error)
        __Pyx_DECREF((PyObject *)__pyx_t_10); __pyx_t_10 = 0;
      }
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_9genexpr35__pyx_v__); __pyx_9genexpr35__pyx_v__ = 0;
      goto __pyx_L21_exit_scope;
      __pyx_L17_error:;
      __Pyx_XDECREF(__pyx_9genexpr35__pyx_v__); __pyx_9genexpr35__pyx_v__ = 0;
      goto __pyx_L1_error;
      __pyx_L21_exit_scope:;
    } /* exit inner scope */
    __pyx_t_4 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_2};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4171, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+4172:             target_asteroid = target_asteroid_original.copy()

  __pyx_t_2 = ((PyObject *)__pyx_v_target_asteroid_original);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4172, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_v_target_asteroid = __pyx_t_3;
  __pyx_t_3 = 0;

+4173:             target_asteroid = time_travel_asteroid(target_asteroid, asteroid_advance_timesteps, self.game_state)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4173, __pyx_L1_error) }
  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_v_target_asteroid, __pyx_v_asteroid_advance_timesteps, __pyx_t_12};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_4, (4-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __Pyx_DECREF_SET(__pyx_v_target_asteroid, __pyx_t_3);
  __pyx_t_3 = 0;

 4174:             # debug_print(f"We're targetting asteroid {ast_to_string(target_asteroid)}")

 4175:             # debug_print(f"Entering the bullet target sim, we're on timestep {self.initial_timestep + self.future_timesteps + len(aiming_move_sequence)}")

 4176:             # debug_print(self.game_state.asteroids)

 4177:             #if not (abs(current_ship_state.velocity[0]) < GRAIN and abs(current_ship_state.velocity[1]) < GRAIN):

 4178:                 # debug_print(f"Current ship velocity is {current_ship_state.velocity}")

+4179:             ship_state_after_aiming = self.get_ship_state()

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4179, __pyx_L1_error) }
  __pyx_t_8 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_8);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_ship_state, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4179, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_v_ship_state_after_aiming = __pyx_t_3;
  __pyx_t_3 = 0;

+4180:             ship_state_after_aiming.heading = (ship_state_after_aiming.heading + target_asteroid_shooting_angle_error_deg) % 360.0

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state_after_aiming, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_target_asteroid_shooting_angle_error_deg); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_12 = PyNumber_Add(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyFloat_RemainderObjC(__pyx_t_12, __pyx_mstate_global->__pyx_float_360_0, 360.0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_ship_state_after_aiming, __pyx_mstate_global->__pyx_n_u_heading, __pyx_t_8) < 0) __PYX_ERR(0, 4180, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+4181:             actual_asteroid_hit, timesteps_until_bullet_hit_asteroid, _ = self.bullet_sim(ship_state_after_aiming, self.fire_first_timestep, len(aiming_move_sequence))

  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4181, __pyx_L1_error) }
  __pyx_t_12 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_12);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4181, __pyx_L1_error) }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_first_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyObject_Length(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4181, __pyx_L1_error)
  __pyx_t_2 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_12, __pyx_v_ship_state_after_aiming, __pyx_t_3, __pyx_t_2};
    __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_bullet_sim, __pyx_callargs+__pyx_t_4, (4-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4181, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
  }
  if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) {
    PyObject* sequence = __pyx_t_8;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 4181, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2);
      __Pyx_INCREF(__pyx_t_12);
    } else {
      __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 0);
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4181, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 1);
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4181, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_3);
      __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 2);
      if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4181, __pyx_L1_error)
      __Pyx_XGOTREF(__pyx_t_12);
    }
    #else
    __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4181, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4181, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_12 = __Pyx_PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4181, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    #endif
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_10 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4181, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10);
    index = 0; __pyx_t_2 = __pyx_t_15(__pyx_t_10); if (unlikely(!__pyx_t_2)) goto __pyx_L22_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_15(__pyx_t_10); if (unlikely(!__pyx_t_3)) goto __pyx_L22_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_12 = __pyx_t_15(__pyx_t_10); if (unlikely(!__pyx_t_12)) goto __pyx_L22_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_12);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_15(__pyx_t_10), 3) < 0) __PYX_ERR(0, 4181, __pyx_L1_error)
    __pyx_t_15 = NULL;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    goto __pyx_L23_unpacking_done;
    __pyx_L22_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_15 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 4181, __pyx_L1_error)
    __pyx_L23_unpacking_done:;
  }
  __pyx_v_actual_asteroid_hit = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_timesteps_until_bullet_hit_asteroid = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v__ = __pyx_t_12;
  __pyx_t_12 = 0;

+4182:             return actual_asteroid_hit, aiming_move_sequence, target_asteroid, target_asteroid_shooting_angle_error_deg, target_asteroid_interception_time_s, target_asteroid_turning_timesteps, timesteps_until_bullet_hit_asteroid, ship_state_after_aiming

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_target_asteroid_shooting_angle_error_deg); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_12 = PyFloat_FromDouble(__pyx_v_target_asteroid_interception_time_s); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_3 = PyTuple_New(8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_actual_asteroid_hit);
  __Pyx_GIVEREF(__pyx_v_actual_asteroid_hit);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_actual_asteroid_hit) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_aiming_move_sequence);
  __Pyx_GIVEREF(__pyx_v_aiming_move_sequence);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_aiming_move_sequence) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_target_asteroid);
  __Pyx_GIVEREF(__pyx_v_target_asteroid);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_target_asteroid) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_8) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_12);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_t_12) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_target_asteroid_turning_timesteps);
  __Pyx_GIVEREF(__pyx_v_target_asteroid_turning_timesteps);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 5, __pyx_v_target_asteroid_turning_timesteps) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
  __Pyx_GIVEREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 6, __pyx_v_timesteps_until_bullet_hit_asteroid) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_ship_state_after_aiming);
  __Pyx_GIVEREF(__pyx_v_ship_state_after_aiming);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 7, __pyx_v_ship_state_after_aiming) != (0)) __PYX_ERR(0, 4182, __pyx_L1_error);
  __pyx_t_8 = 0;
  __pyx_t_12 = 0;
  __pyx_r = ((PyObject*)__pyx_t_3);
  __pyx_t_3 = 0;
  goto __pyx_L0;

 4183: 

 4184:         # First, find the most imminent asteroid

 4185:         # print('\nGOING INTO FUNCTION TO GET ALL FEASIBLE TARGETS FOR ASTEROIDS')

+4186:         target_asteroids_list: list[Target] = []

  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4186, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_target_asteroids_list = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 4187:         #dummy_ship_state: Ship = {'is_respawning': False, 'position': self.ship_state.position, 'velocity': (0.0, 0.0), 'speed': 0.0, 'heading': self.ship_state.heading, 'mass': 300.0, 'radius': 20.0, 'id': self.ship_state.id, 'team': self.ship_state.team, 'lives_remaining': 123, 'bullets_remaining': 0, 'mines_remaining': 0, 'can_fire': self.ship_state.can_fire, 'fire_rate': 10.0, 'thrust_range': (-480.0, 480.0), 'turn_rate_range': (-180.0, 180.0), 'max_speed': 240, 'drag': 80.0}

+4188:         dummy_ship_state = Ship(

  __pyx_t_1 = NULL;
  __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship);
  __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Ship); 

 4189:             is_respawning=False,

+4190:             position=self.ship_state.position,

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 4191:             velocity=(0.0, 0.0),

 4192:             speed=0.0,

+4193:             heading=self.ship_state.heading,

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 4194:             mass=300.0,

 4195:             radius=20.0,

+4196:             id=self.ship_state.id,

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4196, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_id); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4196, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4197:             team=self.ship_state.team,

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_team); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4197, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 4198:             lives_remaining=123,

 4199:             bullets_remaining=0,

 4200:             mines_remaining=0,

+4201:             can_fire=self.ship_state.can_fire,

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_can_fire); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 4202:             fire_rate=10.0,

+4203:             thrust_range=(-480.0, 480.0),

  __pyx_mstate_global->__pyx_tuple[23] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_float_neg_480_0, __pyx_mstate_global->__pyx_float_480_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[23])) __PYX_ERR(0, 4203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[23]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[23]);

+4204:             turn_rate_range=(-180.0, 180.0),

  __pyx_t_10 = 1;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 18 : 0)] = {__pyx_t_1, NULL};
    __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(18); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4188, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_is_respawning, Py_False, __pyx_t_4, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_5, __pyx_t_4, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_tuple[0], __pyx_t_4, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_speed, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_4, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_heading, __pyx_t_6, __pyx_t_4, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_mstate_global->__pyx_float_300_0, __pyx_t_4, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_radius, __pyx_mstate_global->__pyx_float_20_0, __pyx_t_4, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_id, __pyx_t_7, __pyx_t_4, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_team, __pyx_t_8, __pyx_t_4, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_lives_remaining, __pyx_mstate_global->__pyx_int_123, __pyx_t_4, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_bullets_remaining, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mines_remaining, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_can_fire, __pyx_t_9, __pyx_t_4, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_rate, __pyx_mstate_global->__pyx_float_10_0, __pyx_t_4, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust_range, __pyx_mstate_global->__pyx_tuple[23], __pyx_t_4, __pyx_callargs+1, 14) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate_range, __pyx_mstate_global->__pyx_tuple[24], __pyx_t_4, __pyx_callargs+1, 15) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_max_speed, __pyx_mstate_global->__pyx_int_240, __pyx_t_4, __pyx_callargs+1, 16) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_drag, __pyx_mstate_global->__pyx_float_80_0, __pyx_t_4, __pyx_callargs+1, 17) < 0) __PYX_ERR(0, 4188, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4188, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_2);
  }
  __pyx_v_dummy_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)__pyx_t_2);
  __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[24] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_float_neg_180_0, __pyx_mstate_global->__pyx_float_180_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[24])) __PYX_ERR(0, 4204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[24]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[24]);

 4205:             max_speed=240,

 4206:             drag=80.0

 4207:         )

 4208: 

 4209:         timesteps_until_can_fire: int

+4210:         if self.fire_first_timestep:

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_first_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4210, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4210, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_11) {
/* … */
    goto __pyx_L3;
  }

+4211:             timesteps_until_can_fire = FIRE_COOLDOWN_TS

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_FIRE_COOLDOWN_TS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (!(likely(PyLong_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_2))) __PYX_ERR(0, 4211, __pyx_L1_error)
    __pyx_v_timesteps_until_can_fire = ((PyObject*)__pyx_t_2);
    __pyx_t_2 = 0;

 4212:         else:

+4213:             timesteps_until_can_fire = max(0, FIRE_COOLDOWN_TS - (self.initial_timestep + self.future_timesteps - self.last_timestep_fired))

  /*else*/ {
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_FIRE_COOLDOWN_TS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_9 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyNumber_Subtract(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_Subtract(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_12 = 0;
    __pyx_t_2 = __Pyx_PyLong_From_long(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_9 = PyObject_RichCompare(__pyx_t_4, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4213, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_11) {
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_3 = __pyx_t_4;
    } else {
      __pyx_t_9 = __Pyx_PyLong_From_long(__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4213, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_3 = __pyx_t_9;
      __pyx_t_9 = 0;
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __pyx_t_3;
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (!(likely(PyLong_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_4))) __PYX_ERR(0, 4213, __pyx_L1_error)
    __pyx_v_timesteps_until_can_fire = ((PyObject*)__pyx_t_4);
    __pyx_t_4 = 0;
  }
  __pyx_L3:;

 4214:         # debug_print(f"\nSimulation starting from timestep {self.initial_timestep + self.future_timesteps}, and we need to wait this many until we can fire: {timesteps_until_can_fire}")

+4215:         most_imminent_asteroid_exists = False

  __pyx_v_most_imminent_asteroid_exists = 0;

+4216:         asteroids_still_exist = False

  __pyx_v_asteroids_still_exist = 0;

 4217:         # print(self.forecasted_asteroid_splits)

 4218: 

+4219:         for asteroid in chain(self.game_state.asteroids, self.forecasted_asteroid_splits):

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_10 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_10 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_8, __pyx_t_2};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
    __pyx_t_9 = __pyx_t_4; __Pyx_INCREF(__pyx_t_9);
    __pyx_t_13 = 0;
    __pyx_t_14 = NULL;
  } else {
    __pyx_t_13 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4219, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_14 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 4219, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  for (;;) {
    if (likely(!__pyx_t_14)) {
      if (likely(PyList_CheckExact(__pyx_t_9))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4219, __pyx_L1_error)
          #endif
          if (__pyx_t_13 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_13);
        ++__pyx_t_13;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4219, __pyx_L1_error)
          #endif
          if (__pyx_t_13 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_13));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_13);
        #endif
        ++__pyx_t_13;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4219, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_14(__pyx_t_9);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4219, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4220:             if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps, self.game_state, asteroid):

    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4220, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4220, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4220, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4220, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = PyNumber_Add(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4220, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4220, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[5] = {__pyx_t_2, __pyx_t_3, __pyx_t_5, __pyx_t_6, __pyx_v_asteroid};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4220, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4220, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__pyx_t_11) {
/* … */
    }

+4221:                 asteroids_still_exist = True

      __pyx_v_asteroids_still_exist = 1;

 4222:                 # print(f"\nOn TS {self.initial_timestep + self.future_timesteps} We do not have a pending shot for the asteroid {ast_to_string(asteroid)}")

 4223: 

+4224:                 best_feasible_unwrapped_target: Optional[tuple[bool, float, int, float, float, float, float]] = None

      __Pyx_INCREF(Py_None);
      __Pyx_XDECREF_SET(__pyx_v_best_feasible_unwrapped_target, ((PyObject*)Py_None));

 4225:                 # Check whether there are any mines that are about to go off, and if so, project this asteroid into the future to when the mine goes off to get a boolean of whether the asteroid will get hit by the mine or not.

+4226:                 asteroid_will_get_hit_by_my_mine = False

      __pyx_v_asteroid_will_get_hit_by_my_mine = 0;

+4227:                 asteroid_will_get_hit_by_their_mine = False

      __pyx_v_asteroid_will_get_hit_by_their_mine = 0;

+4228:                 for m in self.game_state.mines:

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4228, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4228, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) {
        __pyx_t_4 = __pyx_t_8; __Pyx_INCREF(__pyx_t_4);
        __pyx_t_15 = 0;
        __pyx_t_16 = NULL;
      } else {
        __pyx_t_15 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4228, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 4228, __pyx_L1_error)
      }
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      for (;;) {
        if (likely(!__pyx_t_16)) {
          if (likely(PyList_CheckExact(__pyx_t_4))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4228, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_15);
            ++__pyx_t_15;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4228, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_15));
            #else
            __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_15);
            #endif
            ++__pyx_t_15;
          }
          if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4228, __pyx_L1_error)
        } else {
          __pyx_t_8 = __pyx_t_16(__pyx_t_4);
          if (unlikely(!__pyx_t_8)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4228, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_8);
        __pyx_t_8 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      goto __pyx_L16_for_end;
      __pyx_L8_break:;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      goto __pyx_L16_for_end;
      __pyx_L16_for_end:;

 4229:                     #project_asteroid_by_timesteps_num = round(m.remaining_time*FPS)

 4230:                     #asteroid_when_mine_explodes = time_travel_asteroid(asteroid, project_asteroid_by_timesteps_num, self.game_state)

+4231:                     asteroid_when_mine_explodes = time_travel_asteroid_s(asteroid, m.remaining_time, self.game_state)

        __pyx_t_6 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid_s); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4231, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4231, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4231, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_5))) {
          __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
          assert(__pyx_t_6);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
          __Pyx_INCREF(__pyx_t_6);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_v_asteroid, __pyx_t_3, __pyx_t_2};
          __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4231, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
        }
        __Pyx_XDECREF_SET(__pyx_v_asteroid_when_mine_explodes, __pyx_t_8);
        __pyx_t_8 = 0;

 4232:                     #if check_collision(asteroid_when_mine_explodes.position[0], asteroid_when_mine_explodes.position[1], asteroid_when_mine_explodes.radius, m.position[0], m.position[1], MINE_BLAST_RADIUS):

+4233:                     delta_x = asteroid_when_mine_explodes.position[0] - m.position[0]

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4233, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4233, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4233, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4233, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = PyNumber_Subtract(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4233, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_8);
        __pyx_t_8 = 0;

+4234:                     delta_y = asteroid_when_mine_explodes.position[1] - m.position[1]

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4234, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4234, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4234, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4234, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = PyNumber_Subtract(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4234, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_8);
        __pyx_t_8 = 0;

+4235:                     separation = asteroid_when_mine_explodes.radius + MINE_BLAST_RADIUS

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4235, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4235, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_2 = PyNumber_Add(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4235, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_2);
        __pyx_t_2 = 0;

+4236:                     if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

        __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (__pyx_t_17) {
        } else {
          __pyx_t_11 = __pyx_t_17;
          goto __pyx_L10_bool_binop_done;
        }
        __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_2 = PyObject_RichCompare(__pyx_t_5, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (__pyx_t_17) {
        } else {
          __pyx_t_11 = __pyx_t_17;
          goto __pyx_L10_bool_binop_done;
        }
        __pyx_t_2 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_5 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_8 = PyNumber_Add(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_2 = PyObject_RichCompare(__pyx_t_8, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4236, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_11 = __pyx_t_17;
        __pyx_L10_bool_binop_done:;
        if (__pyx_t_11) {
/* … */
        }

 4237:                         # Keep track of whose mine this is. If it's mine, I want more asteroids to be in its blast radius so it does more damage. If it's theirs, I want to shoot asteroids within its blast radius so it does less damage.

+4238:                         if m.position in self.mine_positions_placed:

          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4238, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4238, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_11 = (__Pyx_PySequence_ContainsTF(__pyx_t_2, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4238, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (__pyx_t_11) {
/* … */
            goto __pyx_L13;
          }

+4239:                             asteroid_will_get_hit_by_my_mine = True

            __pyx_v_asteroid_will_get_hit_by_my_mine = 1;

 4240:                             #print('WILL BE HIT BY MY MINE')

+4241:                             if asteroid_will_get_hit_by_their_mine:

            if (__pyx_v_asteroid_will_get_hit_by_their_mine) {
/* … */
            }

+4242:                                 break

              goto __pyx_L8_break;

 4243:                         else:

 4244:                             #print('WILL BE HIT BY THEIR MINE')

+4245:                             asteroid_will_get_hit_by_their_mine = True

          /*else*/ {
            __pyx_v_asteroid_will_get_hit_by_their_mine = 1;

+4246:                             if asteroid_will_get_hit_by_my_mine:

            if (__pyx_v_asteroid_will_get_hit_by_my_mine) {
/* … */
            }
          }
          __pyx_L13:;

+4247:                                 break

              goto __pyx_L8_break;

 4248:                 # Iterate through all unwrapped asteroids to find which one of the unwraps is the best feasible target.

 4249:                 # 99% of the time, only one of the unwraps will have a feasible target, but there's situations where we could either shoot the asteroid before it wraps, or wait for it to wrap and then shoot it.

 4250:                 # In these cases, we need to pick whichever option is the fastest when factoring in turn time and waiting time.

+4251:                 unwrapped_asteroids = unwrap_asteroid(asteroid, self.game_state.map_size[0], self.game_state.map_size[1], UNWRAP_ASTEROID_TARGET_SELECTION_TIME_HORIZON, True)

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_unwrap_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_UNWRAP_ASTEROID_TARGET_SELECTION); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4251, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_2))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[6] = {__pyx_t_5, __pyx_v_asteroid, __pyx_t_8, __pyx_t_3, __pyx_t_6, Py_True};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_10, (6-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4251, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_unwrapped_asteroids, __pyx_t_4);
      __pyx_t_4 = 0;

+4252:                 for a in unwrapped_asteroids:

      if (likely(PyList_CheckExact(__pyx_v_unwrapped_asteroids)) || PyTuple_CheckExact(__pyx_v_unwrapped_asteroids)) {
        __pyx_t_4 = __pyx_v_unwrapped_asteroids; __Pyx_INCREF(__pyx_t_4);
        __pyx_t_15 = 0;
        __pyx_t_16 = NULL;
      } else {
        __pyx_t_15 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_unwrapped_asteroids); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4252, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 4252, __pyx_L1_error)
      }
      for (;;) {
        if (likely(!__pyx_t_16)) {
          if (likely(PyList_CheckExact(__pyx_t_4))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4252, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_15);
            ++__pyx_t_15;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4252, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_15));
            #else
            __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_15);
            #endif
            ++__pyx_t_15;
          }
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4252, __pyx_L1_error)
        } else {
          __pyx_t_2 = __pyx_t_16(__pyx_t_4);
          if (unlikely(!__pyx_t_2)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4252, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_2);
        __pyx_t_2 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4253:                     feasible, shooting_angle_error_deg, aiming_timesteps_required, interception_time_s, intercept_x, intercept_y, asteroid_dist_during_interception = solve_interception(a, dummy_ship_state, self.game_state, timesteps_until_can_fire)

        __pyx_t_6 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_solve_interception); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4253, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4253, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
          assert(__pyx_t_6);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_6);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_6, __pyx_v_a, ((PyObject *)__pyx_v_dummy_ship_state), __pyx_t_8, __pyx_v_timesteps_until_can_fire};
          __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4253, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
          PyObject* sequence = __pyx_t_2;
          Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
          if (unlikely(size != 7)) {
            if (size > 7) __Pyx_RaiseTooManyValuesError(7);
            else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
            __PYX_ERR(0, 4253, __pyx_L1_error)
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          if (likely(PyTuple_CheckExact(sequence))) {
            __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
            __Pyx_INCREF(__pyx_t_3);
            __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1);
            __Pyx_INCREF(__pyx_t_8);
            __pyx_t_6 = PyTuple_GET_ITEM(sequence, 2);
            __Pyx_INCREF(__pyx_t_6);
            __pyx_t_5 = PyTuple_GET_ITEM(sequence, 3);
            __Pyx_INCREF(__pyx_t_5);
            __pyx_t_7 = PyTuple_GET_ITEM(sequence, 4);
            __Pyx_INCREF(__pyx_t_7);
            __pyx_t_1 = PyTuple_GET_ITEM(sequence, 5);
            __Pyx_INCREF(__pyx_t_1);
            __pyx_t_18 = PyTuple_GET_ITEM(sequence, 6);
            __Pyx_INCREF(__pyx_t_18);
          } else {
            __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 0);
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4253, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_3);
            __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 1);
            if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4253, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_8);
            __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 2);
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4253, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_6);
            __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 3);
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4253, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_5);
            __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 4);
            if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4253, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_7);
            __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 5);
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4253, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_1);
            __pyx_t_18 = __Pyx_PyList_GetItemRef(sequence, 6);
            if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4253, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_18);
          }
          #else
          {
            Py_ssize_t i;
            PyObject** temps[7] = {&__pyx_t_3,&__pyx_t_8,&__pyx_t_6,&__pyx_t_5,&__pyx_t_7,&__pyx_t_1,&__pyx_t_18};
            for (i=0; i < 7; i++) {
              PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4253, __pyx_L1_error)
              __Pyx_GOTREF(item);
              *(temps[i]) = item;
            }
          }
          #endif
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        } else {
          Py_ssize_t index = -1;
          PyObject** temps[7] = {&__pyx_t_3,&__pyx_t_8,&__pyx_t_6,&__pyx_t_5,&__pyx_t_7,&__pyx_t_1,&__pyx_t_18};
          __pyx_t_19 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4253, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_20 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_19);
          for (index=0; index < 7; index++) {
            PyObject* item = __pyx_t_20(__pyx_t_19); if (unlikely(!item)) goto __pyx_L19_unpacking_failed;
            __Pyx_GOTREF(item);
            *(temps[index]) = item;
          }
          if (__Pyx_IternextUnpackEndCheck(__pyx_t_20(__pyx_t_19), 7) < 0) __PYX_ERR(0, 4253, __pyx_L1_error)
          __pyx_t_20 = NULL;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          goto __pyx_L20_unpacking_done;
          __pyx_L19_unpacking_failed:;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_20 = NULL;
          if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
          __PYX_ERR(0, 4253, __pyx_L1_error)
          __pyx_L20_unpacking_done:;
        }
        __Pyx_XDECREF_SET(__pyx_v_feasible, __pyx_t_3);
        __pyx_t_3 = 0;
        __Pyx_XDECREF_SET(__pyx_v_shooting_angle_error_deg, __pyx_t_8);
        __pyx_t_8 = 0;
        __Pyx_XDECREF_SET(__pyx_v_aiming_timesteps_required, __pyx_t_6);
        __pyx_t_6 = 0;
        __Pyx_XDECREF_SET(__pyx_v_interception_time_s, __pyx_t_5);
        __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_intercept_x, __pyx_t_7);
        __pyx_t_7 = 0;
        __Pyx_XDECREF_SET(__pyx_v_intercept_y, __pyx_t_1);
        __pyx_t_1 = 0;
        __Pyx_XDECREF_SET(__pyx_v_asteroid_dist_during_interception, __pyx_t_18);
        __pyx_t_18 = 0;

 4254: 

+4255:                     if feasible:

        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_feasible); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4255, __pyx_L1_error)
        if (__pyx_t_11) {
/* … */
        }

+4256:                         assert aiming_timesteps_required is not None  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_11 = (__pyx_v_aiming_timesteps_required != Py_None);
            if (unlikely(!__pyx_t_11)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 4256, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 4256, __pyx_L1_error)
          #endif

+4257:                         if best_feasible_unwrapped_target is None or aiming_timesteps_required < best_feasible_unwrapped_target[2]:

          __pyx_t_17 = (__pyx_v_best_feasible_unwrapped_target == ((PyObject*)Py_None));
          if (!__pyx_t_17) {
          } else {
            __pyx_t_11 = __pyx_t_17;
            goto __pyx_L23_bool_binop_done;
          }
          if (unlikely(__pyx_v_best_feasible_unwrapped_target == Py_None)) {
            PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
            __PYX_ERR(0, 4257, __pyx_L1_error)
          }
          __pyx_t_2 = PyObject_RichCompare(__pyx_v_aiming_timesteps_required, __Pyx_PyTuple_GET_ITEM(__pyx_v_best_feasible_unwrapped_target, 2), Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4257, __pyx_L1_error)
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4257, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_11 = __pyx_t_17;
          __pyx_L23_bool_binop_done:;
          if (__pyx_t_11) {
/* … */
          }

 4258:                             #print((feasible, shooting_angle_error_deg, aiming_timesteps_required, interception_time_s, intercept_x, intercept_y, asteroid_dist_during_interception))

+4259:                             best_feasible_unwrapped_target = (feasible, shooting_angle_error_deg, aiming_timesteps_required, interception_time_s, intercept_x, intercept_y, asteroid_dist_during_interception)

            __pyx_t_2 = PyTuple_New(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4259, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __Pyx_INCREF(__pyx_v_feasible);
            __Pyx_GIVEREF(__pyx_v_feasible);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_feasible) != (0)) __PYX_ERR(0, 4259, __pyx_L1_error);
            __Pyx_INCREF(__pyx_v_shooting_angle_error_deg);
            __Pyx_GIVEREF(__pyx_v_shooting_angle_error_deg);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_shooting_angle_error_deg) != (0)) __PYX_ERR(0, 4259, __pyx_L1_error);
            __Pyx_INCREF(__pyx_v_aiming_timesteps_required);
            __Pyx_GIVEREF(__pyx_v_aiming_timesteps_required);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_aiming_timesteps_required) != (0)) __PYX_ERR(0, 4259, __pyx_L1_error);
            __Pyx_INCREF(__pyx_v_interception_time_s);
            __Pyx_GIVEREF(__pyx_v_interception_time_s);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_interception_time_s) != (0)) __PYX_ERR(0, 4259, __pyx_L1_error);
            __Pyx_INCREF(__pyx_v_intercept_x);
            __Pyx_GIVEREF(__pyx_v_intercept_x);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 4, __pyx_v_intercept_x) != (0)) __PYX_ERR(0, 4259, __pyx_L1_error);
            __Pyx_INCREF(__pyx_v_intercept_y);
            __Pyx_GIVEREF(__pyx_v_intercept_y);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 5, __pyx_v_intercept_y) != (0)) __PYX_ERR(0, 4259, __pyx_L1_error);
            __Pyx_INCREF(__pyx_v_asteroid_dist_during_interception);
            __Pyx_GIVEREF(__pyx_v_asteroid_dist_during_interception);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 6, __pyx_v_asteroid_dist_during_interception) != (0)) __PYX_ERR(0, 4259, __pyx_L1_error);
            __Pyx_DECREF_SET(__pyx_v_best_feasible_unwrapped_target, ((PyObject*)__pyx_t_2));
            __pyx_t_2 = 0;

 4260:                     #else:

 4261:                     #    pass

 4262:                         #print(f'INFEASIBLE SHOT for ast {ast_to_string(a)}')

 4263:                         #print(feasible, shooting_angle_error_deg, aiming_timesteps_required, interception_time_s, intercept_x, intercept_y, asteroid_dist_during_interception)

+4264:                 if best_feasible_unwrapped_target is not None:

      __pyx_t_11 = (__pyx_v_best_feasible_unwrapped_target != ((PyObject*)Py_None));
      if (__pyx_t_11) {
/* … */
      }

+4265:                     feasible, shooting_angle_error_deg, aiming_timesteps_required, interception_time_s, intercept_x, intercept_y, asteroid_dist_during_interception = best_feasible_unwrapped_target

        if (likely(__pyx_v_best_feasible_unwrapped_target != Py_None)) {
          PyObject* sequence = __pyx_v_best_feasible_unwrapped_target;
          Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
          if (unlikely(size != 7)) {
            if (size > 7) __Pyx_RaiseTooManyValuesError(7);
            else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
            __PYX_ERR(0, 4265, __pyx_L1_error)
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
          __Pyx_INCREF(__pyx_t_4);
          __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1);
          __Pyx_INCREF(__pyx_t_2);
          __pyx_t_18 = PyTuple_GET_ITEM(sequence, 2);
          __Pyx_INCREF(__pyx_t_18);
          __pyx_t_1 = PyTuple_GET_ITEM(sequence, 3);
          __Pyx_INCREF(__pyx_t_1);
          __pyx_t_7 = PyTuple_GET_ITEM(sequence, 4);
          __Pyx_INCREF(__pyx_t_7);
          __pyx_t_5 = PyTuple_GET_ITEM(sequence, 5);
          __Pyx_INCREF(__pyx_t_5);
          __pyx_t_6 = PyTuple_GET_ITEM(sequence, 6);
          __Pyx_INCREF(__pyx_t_6);
          #else
          {
            Py_ssize_t i;
            PyObject** temps[7] = {&__pyx_t_4,&__pyx_t_2,&__pyx_t_18,&__pyx_t_1,&__pyx_t_7,&__pyx_t_5,&__pyx_t_6};
            for (i=0; i < 7; i++) {
              PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4265, __pyx_L1_error)
              __Pyx_GOTREF(item);
              *(temps[i]) = item;
            }
          }
          #endif
        } else {
          __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 4265, __pyx_L1_error)
        }
        __Pyx_XDECREF_SET(__pyx_v_feasible, __pyx_t_4);
        __pyx_t_4 = 0;
        __Pyx_XDECREF_SET(__pyx_v_shooting_angle_error_deg, __pyx_t_2);
        __pyx_t_2 = 0;
        __Pyx_XDECREF_SET(__pyx_v_aiming_timesteps_required, __pyx_t_18);
        __pyx_t_18 = 0;
        __Pyx_XDECREF_SET(__pyx_v_interception_time_s, __pyx_t_1);
        __pyx_t_1 = 0;
        __Pyx_XDECREF_SET(__pyx_v_intercept_x, __pyx_t_7);
        __pyx_t_7 = 0;
        __Pyx_XDECREF_SET(__pyx_v_intercept_y, __pyx_t_5);
        __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_asteroid_dist_during_interception, __pyx_t_6);
        __pyx_t_6 = 0;

+4266:                     imminent_collision_time_s = INFINITY

        __pyx_t_6 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4266, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_XDECREF_SET(__pyx_v_imminent_collision_time_s, __pyx_t_6);
        __pyx_t_6 = 0;

+4267:                     assert is_close_to_zero(self.ship_state.velocity[0]) and is_close_to_zero(self.ship_state.velocity[1])  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_5 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_18, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_7))) {
            __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
            assert(__pyx_t_5);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
            __Pyx_INCREF(__pyx_t_5);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_1};
            __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4267, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (__pyx_t_17) {
          } else {
            __pyx_t_11 = __pyx_t_17;
            goto __pyx_L27_bool_binop_done;
          }
          __pyx_t_7 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_18, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_1))) {
            __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
            assert(__pyx_t_7);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
            __Pyx_INCREF(__pyx_t_7);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5};
            __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4267, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4267, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_11 = __pyx_t_17;
          __pyx_L27_bool_binop_done:;
          if (unlikely(!__pyx_t_11)) {
            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
            __PYX_ERR(0, 4267, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 4267, __pyx_L1_error)
        #endif

+4268:                     for a in unwrapped_asteroids:

        if (likely(PyList_CheckExact(__pyx_v_unwrapped_asteroids)) || PyTuple_CheckExact(__pyx_v_unwrapped_asteroids)) {
          __pyx_t_6 = __pyx_v_unwrapped_asteroids; __Pyx_INCREF(__pyx_t_6);
          __pyx_t_15 = 0;
          __pyx_t_16 = NULL;
        } else {
          __pyx_t_15 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_v_unwrapped_asteroids); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4268, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 4268, __pyx_L1_error)
        }
        for (;;) {
          if (likely(!__pyx_t_16)) {
            if (likely(PyList_CheckExact(__pyx_t_6))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4268, __pyx_L1_error)
                #endif
                if (__pyx_t_15 >= __pyx_temp) break;
              }
              __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_15);
              ++__pyx_t_15;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4268, __pyx_L1_error)
                #endif
                if (__pyx_t_15 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_15));
              #else
              __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_15);
              #endif
              ++__pyx_t_15;
            }
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4268, __pyx_L1_error)
          } else {
            __pyx_t_1 = __pyx_t_16(__pyx_t_6);
            if (unlikely(!__pyx_t_1)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4268, __pyx_L1_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_1);
          __pyx_t_1 = 0;
/* … */
        }
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+4269:                         imminent_collision_time_s = min(imminent_collision_time_s, predict_next_imminent_collision_time_with_asteroid(self.ship_state.position[0], self.ship_state.position[1], self.ship_state.velocity[0], self.ship_state.velocity[1], SHIP_RADIUS, a.position[0], a.position[1], a.velocity[0], a.velocity[1], a.radius, self.game_state))

          __pyx_t_5 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_predict_next_imminent_collision); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_19, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_19, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_19, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_24 = __Pyx_GetItemInt(__pyx_t_19, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_24);
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_7))) {
            __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
            assert(__pyx_t_5);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
            __Pyx_INCREF(__pyx_t_5);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[12] = {__pyx_t_5, __pyx_t_18, __pyx_t_2, __pyx_t_4, __pyx_t_8, __pyx_t_3, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24, __pyx_t_19, __pyx_t_25};
            __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (12-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
            __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4269, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
          }
          __Pyx_INCREF(__pyx_v_imminent_collision_time_s);
          __pyx_t_7 = __pyx_v_imminent_collision_time_s;
          __pyx_t_19 = PyObject_RichCompare(__pyx_t_1, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4269, __pyx_L1_error)
          __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4269, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          if (__pyx_t_11) {
            __Pyx_INCREF(__pyx_t_1);
            __pyx_t_25 = __pyx_t_1;
          } else {
            __Pyx_INCREF(__pyx_t_7);
            __pyx_t_25 = __pyx_t_7;
          }
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_1 = __pyx_t_25;
          __Pyx_INCREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __Pyx_DECREF_SET(__pyx_v_imminent_collision_time_s, __pyx_t_1);
          __pyx_t_1 = 0;

+4270:                     target_asteroids_list.append(Target(

        __pyx_t_1 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Target);
        __pyx_t_25 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Target); 
/* … */
        __pyx_t_26 = __Pyx_PyList_Append(__pyx_v_target_asteroids_list, ((PyObject *)__pyx_t_6)); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(0, 4270, __pyx_L1_error)
        __Pyx_DECREF((PyObject *)__pyx_t_6); __pyx_t_6 = 0;

+4271:                         asteroid=asteroid.copy(),  # Record the canonical asteroid even if we're shooting at an unwrapped one

        __pyx_t_19 = __pyx_v_asteroid;
        __Pyx_INCREF(__pyx_t_19);
        __pyx_t_10 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_19, NULL};
          __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
          if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4271, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
        }

 4272:                         feasible=feasible,  # Will be True

 4273:                         shooting_angle_error_deg=shooting_angle_error_deg,

 4274:                         aiming_timesteps_required=aiming_timesteps_required,

 4275:                         interception_time_s=interception_time_s,

 4276:                         intercept_x=intercept_x,

 4277:                         intercept_y=intercept_y,

 4278:                         asteroid_dist_during_interception=asteroid_dist_during_interception,

 4279:                         imminent_collision_time_s=imminent_collision_time_s,

+4280:                         asteroid_will_get_hit_by_my_mine=asteroid_will_get_hit_by_my_mine,

        __pyx_t_19 = __Pyx_PyBool_FromLong(__pyx_v_asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4280, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);

+4281:                         asteroid_will_get_hit_by_their_mine=asteroid_will_get_hit_by_their_mine,

        __pyx_t_24 = __Pyx_PyBool_FromLong(__pyx_v_asteroid_will_get_hit_by_their_mine); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4281, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_24);
        __pyx_t_10 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 11 : 0)] = {__pyx_t_1, NULL};
          __pyx_t_23 = __Pyx_MakeVectorcallBuilderKwds(11); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4270, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid, __pyx_t_7, __pyx_t_23, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_feasible, __pyx_v_feasible, __pyx_t_23, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg, __pyx_v_shooting_angle_error_deg, __pyx_t_23, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_aiming_timesteps_required, __pyx_v_aiming_timesteps_required, __pyx_t_23, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_interception_time_s, __pyx_v_interception_time_s, __pyx_t_23, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_intercept_x, __pyx_v_intercept_x, __pyx_t_23, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_intercept_y, __pyx_v_intercept_y, __pyx_t_23, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid_dist_during_interceptio, __pyx_v_asteroid_dist_during_interception, __pyx_t_23, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_imminent_collision_time_s, __pyx_v_imminent_collision_time_s, __pyx_t_23, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_my_mine, __pyx_t_19, __pyx_t_23, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_their_m, __pyx_t_24, __pyx_t_23, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 4270, __pyx_L1_error)
          __pyx_t_6 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_25, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_23);
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4270, __pyx_L1_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_6);
        }

 4282:                     ))

+4283:                     if imminent_collision_time_s < INFINITY:

        __pyx_t_6 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4283, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_25 = PyObject_RichCompare(__pyx_v_imminent_collision_time_s, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_25); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4283, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4283, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        if (__pyx_t_11) {
/* … */
        }

 4284:                         # debug_print(f"Imminent collision time is less than inf! {imminent_collision_time_s}")

+4285:                         most_imminent_asteroid_exists = True

          __pyx_v_most_imminent_asteroid_exists = 1;

 4286:         # Check whether we have enough time to aim at it and shoot it down

 4287:         # PROBLEM, what if the asteroid breaks into pieces and I need to shoot those down too? But I have plenty of time, and I still want the fitness function to be good in that case, but there's no easy way to evaluate that. It's hard to decide whether we want to shoot the asteroids that are about to hit us, or to just dodge it by moving myself.

 4288: 

+4289:         turn_angle_deg_until_can_fire = float(timesteps_until_can_fire)*SHIP_MAX_TURN_RATE*DELTA_TIME  # Can be up to 18 degrees

  if (unlikely(__pyx_v_timesteps_until_can_fire == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "float() argument must be a string or a number, not 'NoneType'");
    __PYX_ERR(0, 4289, __pyx_L1_error)
  }
  __pyx_t_27 = PyLong_AsDouble(__pyx_v_timesteps_until_can_fire); if (unlikely(__pyx_t_27 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4289, __pyx_L1_error)
  __pyx_t_9 = PyFloat_FromDouble(__pyx_t_27); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4289, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4289, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_9, __pyx_t_25); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4289, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4289, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __pyx_t_9 = PyNumber_Multiply(__pyx_t_6, __pyx_t_25); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4289, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
  __pyx_v_turn_angle_deg_until_can_fire = __pyx_t_9;
  __pyx_t_9 = 0;

 4290:         # print(target_asteroids_list)

 4291:         # if there’s an imminent shot coming toward me, I will aim at the asteroid that gets me CLOSEST to the direction of the imminent shot.

 4292:         # So it only plans one shot at a time instead of a series of shots, and it’ll keep things simpler

 4293:         # debug_print(f"Least angular dist: {least_angular_distance_asteroid_shooting_angle_error_deg}")

 4294:         # debug_print('Target asts list: ', target_asteroids_list)

+4295:         actual_asteroid_hit = None

  __Pyx_INCREF(Py_None);
  __pyx_v_actual_asteroid_hit = Py_None;

+4296:         aiming_move_sequence: list[Action] = []

  __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4296, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_v_aiming_move_sequence = ((PyObject*)__pyx_t_9);
  __pyx_t_9 = 0;

 4297: 

+4298:         if most_imminent_asteroid_exists:

  if (__pyx_v_most_imminent_asteroid_exists) {
/* … */
  }

 4299:             # First try to shoot the most imminent asteroids, if they exist

 4300: 

 4301:             # debug_print(f"Shooting at most imminent asteroids. Most imminent collision time is {most_imminent_collision_time_s}s with turn angle error {most_imminent_asteroid_shooting_angle_error_deg}")

 4302:             # debug_print(most_imminent_asteroid)

 4303:             # Find the asteroid I can shoot at that gets me closest to the imminent shot, if I can't reach the imminent shot in time until I can shoot

 4304:             # Sort the targets such that we prioritize asteroids that are about to hit me

 4305:             # If there's a bullet limit, penalize risky shots more

+4306:             sorted_imminent_targets = target_asteroids_list

    __Pyx_INCREF(__pyx_v_target_asteroids_list);
    __pyx_v_sorted_imminent_targets = __pyx_v_target_asteroids_list;

+4307:             if self.other_ships:

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4307, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_11) {
/* … */
      goto __pyx_L35;
    }

+4308:                 frontrun_score_multiplier = 4.0 if self.ship_state.bullets_remaining > 0 else 3.0

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4308, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4308, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyObject_RichCompare(__pyx_t_25, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4308, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4308, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (__pyx_t_11) {
        __pyx_t_27 = 4.0;
      } else {
        __pyx_t_27 = 3.0;
      }
      __pyx_cur_scope->__pyx_v_frontrun_score_multiplier = __pyx_t_27;

+4309:                 sorted_imminent_targets.sort(key=lambda t: (

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_2lambda7(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_16target_selection_2lambda7 = {"lambda7", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_16target_selection_2lambda7, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_2lambda7(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_t = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda7 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_t,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4309, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4309, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda7", 0) < 0) __PYX_ERR(0, 4309, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda7", 1, 1, 1, i); __PYX_ERR(0, 4309, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4309, __pyx_L3_error)
    }
    __pyx_v_t = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("lambda7", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4309, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda7", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_lambda_funcdef_lambda7(__pyx_self, __pyx_v_t);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_lambda_funcdef_lambda7(PyObject *__pyx_self, PyObject *__pyx_v_t) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *__pyx_outer_scope;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda7", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
      __pyx_t_25 = __pyx_v_sorted_imminent_targets;
      __Pyx_INCREF(__pyx_t_25);
      __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_16target_selection_2lambda7, 0, __pyx_mstate_global->__pyx_n_u_Matrix_target_selection_locals_l, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4309, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_25, NULL};
        __pyx_t_23 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4309, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_6, __pyx_t_23, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4309, __pyx_L1_error)
        __pyx_t_9 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_23);
        __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4309, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4310:                     min(10, t.imminent_collision_time_s) +

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_imminent_collision_time_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = 10;
  __pyx_t_4 = __Pyx_PyLong_From_long(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4310, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4310, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_6) {
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_3 = __pyx_t_1;
  } else {
    __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4310, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
    __pyx_t_5 = 0;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4311:                     ASTEROID_SIZE_SHOT_PRIORITY[t.asteroid.size]*0.25 +

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ASTEROID_SIZE_SHOT_PRIORITY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_5, __pyx_mstate_global->__pyx_float_0_25); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
  __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4312:                     t.interception_time_s + # Might be more correct to do t.interception_time_s + t.aiming_timesteps_required*DELTA_TIME - get_adversary_interception_time_lower_bound(t.asteroid, self.other_ships, self.game_state)

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_interception_time_s); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4312, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
/* … */
  __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4312, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+4313:                     t.asteroid_dist_during_interception/400.0 +

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_dist_during_interceptio); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_float_400_0, 400.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+4314:                     frontrun_score_multiplier*min(0.5, max(0, t.interception_time_s - get_adversary_interception_time_lower_bound(t.asteroid, self.other_ships, self.game_state))) +

  __pyx_t_5 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_frontrun_score_multiplier); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_interception_time_s); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_adversary_interception_time); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4314, __pyx_L1_error) }
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4314, __pyx_L1_error) }
  __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_12 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_12 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_t_9, __pyx_t_10, __pyx_t_11};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_12, (4-__pyx_t_12) | (__pyx_t_12*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4314, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_8 = PyNumber_Subtract(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_11 = PyObject_RichCompare(__pyx_t_8, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__pyx_t_6) {
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_1 = __pyx_t_8;
  } else {
    __pyx_t_11 = __Pyx_PyLong_From_long(__pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4314, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_1 = __pyx_t_11;
    __pyx_t_11 = 0;
  }
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_8 = __pyx_t_1;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_13 = 0.5;
  __pyx_t_11 = PyFloat_FromDouble(__pyx_t_13); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_3 = PyObject_RichCompare(__pyx_t_8, __pyx_t_11, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_6) {
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_1 = __pyx_t_8;
  } else {
    __pyx_t_3 = PyFloat_FromDouble(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4314, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __pyx_t_3;
    __pyx_t_3 = 0;
  }
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyNumber_Multiply(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+4315:                     ((5.0 if t.asteroid.size == 1 else -5.0) if t.asteroid_will_get_hit_by_my_mine else 0.0) +

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4315, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_6) {
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4315, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4315, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_14 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4315, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_14) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_5_0);
      __pyx_t_4 = __pyx_mstate_global->__pyx_float_5_0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_5_0);
      __pyx_t_4 = __pyx_mstate_global->__pyx_float_neg_5_0;
    }
    __pyx_t_8 = __pyx_t_4;
    __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_t_8 = __pyx_mstate_global->__pyx_float_0_0;
  }
/* … */
  __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

+4316:                     ((3.0 if t.asteroid.size != 1 else -3.0) if t.asteroid_will_get_hit_by_their_mine else 0.0)

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_their_m); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4316, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4316, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_6) {
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4316, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4316, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_14 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4316, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_14) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_3_0);
      __pyx_t_1 = __pyx_mstate_global->__pyx_float_3_0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_3_0);
      __pyx_t_1 = __pyx_mstate_global->__pyx_float_neg_3_0;
    }
    __pyx_t_8 = __pyx_t_1;
    __pyx_t_1 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_t_8 = __pyx_mstate_global->__pyx_float_0_0;
  }

 4317:                 ))

 4318:             else:

+4319:                 sorted_imminent_targets.sort(key=lambda t: (

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_3lambda8(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_16target_selection_3lambda8 = {"lambda8", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_16target_selection_3lambda8, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_3lambda8(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_t = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda8 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_t,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4319, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4319, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda8", 0) < 0) __PYX_ERR(0, 4319, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda8", 1, 1, 1, i); __PYX_ERR(0, 4319, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4319, __pyx_L3_error)
    }
    __pyx_v_t = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("lambda8", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4319, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda8", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_lambda_funcdef_lambda8(__pyx_self, __pyx_v_t);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_lambda_funcdef_lambda8(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_t) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda8", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
    /*else*/ {
      __pyx_t_23 = __pyx_v_sorted_imminent_targets;
      __Pyx_INCREF(__pyx_t_23);
      __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_16target_selection_3lambda8, 0, __pyx_mstate_global->__pyx_n_u_Matrix_target_selection_locals_l, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4319, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_23, NULL};
        __pyx_t_25 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4319, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_6, __pyx_t_25, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4319, __pyx_L1_error)
        __pyx_t_9 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_25);
        __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4319, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    }
    __pyx_L35:;

+4320:                     min(10, t.imminent_collision_time_s) +

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_imminent_collision_time_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = 10;
  __pyx_t_4 = __Pyx_PyLong_From_long(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4320, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4320, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_6) {
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_3 = __pyx_t_1;
  } else {
    __pyx_t_5 = __Pyx_PyLong_From_long(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4320, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __pyx_t_5;
    __pyx_t_5 = 0;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4321:                     ASTEROID_SIZE_SHOT_PRIORITY[t.asteroid.size]*0.25 +

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ASTEROID_SIZE_SHOT_PRIORITY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_5, __pyx_mstate_global->__pyx_float_0_25); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4321, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+4322:                     t.asteroid_dist_during_interception/400.0 +

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_dist_during_interceptio); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_float_400_0, 400.0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

+4323:                     ((5.0 if t.asteroid.size == 1 else -5.0) if t.asteroid_will_get_hit_by_my_mine else 0.0)

  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4323, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4323, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_6) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4323, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4323, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_8 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 4323, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_8) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_5_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_float_5_0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_5_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_float_neg_5_0;
    }
    __pyx_t_3 = __pyx_t_5;
    __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_t_3 = __pyx_mstate_global->__pyx_float_0_0;
  }

 4324:                 ))

 4325:             # The frontrun time is bounded by 0 and 0.5 seconds, since anything after half a second away is basically the same and there's no point differentiating between them

 4326:             # TODO: For each asteroid, give it a couple feasible times where we wait longer and longer. This way we can choose to wait a timestep to fire again if we'll get luckier with the bullet lining up

+4327:             for _, candidate_target in enumerate(sorted_imminent_targets):

    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_t_9 = __pyx_mstate_global->__pyx_int_0;
    __pyx_t_25 = __pyx_v_sorted_imminent_targets; __Pyx_INCREF(__pyx_t_25);
    __pyx_t_13 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_25);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4327, __pyx_L1_error)
        #endif
        if (__pyx_t_13 >= __pyx_temp) break;
      }
      __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_25, __pyx_t_13);
      ++__pyx_t_13;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4327, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_XDECREF_SET(__pyx_v_candidate_target, __pyx_t_6);
      __pyx_t_6 = 0;
      __Pyx_INCREF(__pyx_t_9);
      __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_9);
      __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4327, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_9);
      __pyx_t_9 = __pyx_t_6;
      __pyx_t_6 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    goto __pyx_L63_for_end;
    __pyx_L37_break:;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    goto __pyx_L63_for_end;
    __pyx_L63_for_end:;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4328:                 if isinf(candidate_target.imminent_collision_time_s):

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_candidate_target, __pyx_mstate_global->__pyx_n_u_imminent_collision_time_s); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4328, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_28 = __Pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_28 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4328, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_11 = (isinf(__pyx_t_28) != 0);
      if (__pyx_t_11) {
/* … */
      }

 4329:                     # Ran through all imminent asteroids! Everything onward won't collide with me anytime soon.

+4330:                     break

        goto __pyx_L37_break;

+4331:                 most_imminent_asteroid_aiming_timesteps = candidate_target.aiming_timesteps_required

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_candidate_target, __pyx_mstate_global->__pyx_n_u_aiming_timesteps_required); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4331, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_XDECREF_SET(__pyx_v_most_imminent_asteroid_aiming_timesteps, __pyx_t_6);
      __pyx_t_6 = 0;

+4332:                 most_imminent_asteroid = candidate_target.asteroid

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_candidate_target, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4332, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_XDECREF_SET(__pyx_v_most_imminent_asteroid, __pyx_t_6);
      __pyx_t_6 = 0;

+4333:                 most_imminent_asteroid_shooting_angle_error_deg = candidate_target.shooting_angle_error_deg

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_candidate_target, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4333, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_XDECREF_SET(__pyx_v_most_imminent_asteroid_shooting_angle_error_deg, __pyx_t_6);
      __pyx_t_6 = 0;

+4334:                 most_imminent_asteroid_interception_time_s = candidate_target.interception_time_s

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_candidate_target, __pyx_mstate_global->__pyx_n_u_interception_time_s); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4334, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_XDECREF_SET(__pyx_v_most_imminent_asteroid_interception_time_s, __pyx_t_6);
      __pyx_t_6 = 0;

 4335:                 # debug_print(f"Shooting at asteroid that's going to hit me: {ast_to_string(most_imminent_asteroid)}")

+4336:                 if most_imminent_asteroid_aiming_timesteps <= timesteps_until_can_fire:

      __pyx_t_6 = PyObject_RichCompare(__pyx_v_most_imminent_asteroid_aiming_timesteps, __pyx_v_timesteps_until_can_fire, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4336, __pyx_L1_error)
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4336, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (__pyx_t_11) {
/* … */
        goto __pyx_L39;
      }

+4337:                     if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4337, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4337, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (__pyx_t_11) {
/* … */
        }

+4338:                         assert most_imminent_asteroid_aiming_timesteps == timesteps_until_can_fire  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_6 = PyObject_RichCompare(__pyx_v_most_imminent_asteroid_aiming_timesteps, __pyx_v_timesteps_until_can_fire, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4338, __pyx_L1_error)
            __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4338, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            if (unlikely(!__pyx_t_11)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 4338, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 4338, __pyx_L1_error)
          #endif

 4339:                     # I can reach the imminent shot without wasting a shot opportunity, so do it

 4340:                     #assert isinstance(most_imminent_asteroid, Asteroid)

 4341:                     #assert isinstance(most_imminent_asteroid_shooting_angle_error_deg, float)

 4342:                     #assert isinstance(most_imminent_asteroid_interception_time_s, float)

 4343:                     #assert isinstance(most_imminent_asteroid_aiming_timesteps, int)

+4344:                     actual_asteroid_hit, aiming_move_sequence, target_asteroid, target_asteroid_shooting_angle_error_deg, target_asteroid_interception_time_s, target_asteroid_turning_timesteps, timesteps_until_bullet_hit_asteroid, ship_state_after_aiming = simulate_shooting_at_target(most_imminent_asteroid, most_imminent_asteroid_shooting_angle_error_deg, most_imminent_asteroid_interception_time_s, most_imminent_asteroid_aiming_timesteps)

        if (!(likely(((__pyx_v_most_imminent_asteroid) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid))))) __PYX_ERR(0, 4344, __pyx_L1_error)
        __pyx_t_27 = __Pyx_PyFloat_AsDouble(__pyx_v_most_imminent_asteroid_shooting_angle_error_deg); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4344, __pyx_L1_error)
        __pyx_t_29 = __Pyx_PyFloat_AsDouble(__pyx_v_most_imminent_asteroid_interception_time_s); if (unlikely((__pyx_t_29 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4344, __pyx_L1_error)
        if (!(likely(PyLong_CheckExact(__pyx_v_most_imminent_asteroid_aiming_timesteps))||((__pyx_v_most_imminent_asteroid_aiming_timesteps) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_v_most_imminent_asteroid_aiming_timesteps))) __PYX_ERR(0, 4344, __pyx_L1_error)
        __pyx_t_6 = __pyx_pf_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target(__pyx_v_simulate_shooting_at_target, ((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_most_imminent_asteroid), __pyx_t_27, __pyx_t_29, ((PyObject*)__pyx_v_most_imminent_asteroid_aiming_timesteps)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4344, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
          PyObject* sequence = __pyx_t_6;
          Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
          if (unlikely(size != 8)) {
            if (size > 8) __Pyx_RaiseTooManyValuesError(8);
            else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
            __PYX_ERR(0, 4344, __pyx_L1_error)
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          if (likely(PyTuple_CheckExact(sequence))) {
            __pyx_t_23 = PyTuple_GET_ITEM(sequence, 0);
            __Pyx_INCREF(__pyx_t_23);
            __pyx_t_24 = PyTuple_GET_ITEM(sequence, 1);
            __Pyx_INCREF(__pyx_t_24);
            __pyx_t_19 = PyTuple_GET_ITEM(sequence, 2);
            __Pyx_INCREF(__pyx_t_19);
            __pyx_t_7 = PyTuple_GET_ITEM(sequence, 3);
            __Pyx_INCREF(__pyx_t_7);
            __pyx_t_1 = PyTuple_GET_ITEM(sequence, 4);
            __Pyx_INCREF(__pyx_t_1);
            __pyx_t_22 = PyTuple_GET_ITEM(sequence, 5);
            __Pyx_INCREF(__pyx_t_22);
            __pyx_t_21 = PyTuple_GET_ITEM(sequence, 6);
            __Pyx_INCREF(__pyx_t_21);
            __pyx_t_3 = PyTuple_GET_ITEM(sequence, 7);
            __Pyx_INCREF(__pyx_t_3);
          } else {
            __pyx_t_23 = __Pyx_PyList_GetItemRef(sequence, 0);
            if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_23);
            __pyx_t_24 = __Pyx_PyList_GetItemRef(sequence, 1);
            if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_24);
            __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 2);
            if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_19);
            __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 3);
            if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_7);
            __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 4);
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_1);
            __pyx_t_22 = __Pyx_PyList_GetItemRef(sequence, 5);
            if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_22);
            __pyx_t_21 = __Pyx_PyList_GetItemRef(sequence, 6);
            if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_21);
            __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 7);
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4344, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_3);
          }
          #else
          {
            Py_ssize_t i;
            PyObject** temps[8] = {&__pyx_t_23,&__pyx_t_24,&__pyx_t_19,&__pyx_t_7,&__pyx_t_1,&__pyx_t_22,&__pyx_t_21,&__pyx_t_3};
            for (i=0; i < 8; i++) {
              PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4344, __pyx_L1_error)
              __Pyx_GOTREF(item);
              *(temps[i]) = item;
            }
          }
          #endif
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        } else {
          Py_ssize_t index = -1;
          PyObject** temps[8] = {&__pyx_t_23,&__pyx_t_24,&__pyx_t_19,&__pyx_t_7,&__pyx_t_1,&__pyx_t_22,&__pyx_t_21,&__pyx_t_3};
          __pyx_t_8 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4344, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_20 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8);
          for (index=0; index < 8; index++) {
            PyObject* item = __pyx_t_20(__pyx_t_8); if (unlikely(!item)) goto __pyx_L41_unpacking_failed;
            __Pyx_GOTREF(item);
            *(temps[index]) = item;
          }
          if (__Pyx_IternextUnpackEndCheck(__pyx_t_20(__pyx_t_8), 8) < 0) __PYX_ERR(0, 4344, __pyx_L1_error)
          __pyx_t_20 = NULL;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          goto __pyx_L42_unpacking_done;
          __pyx_L41_unpacking_failed:;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_20 = NULL;
          if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
          __PYX_ERR(0, 4344, __pyx_L1_error)
          __pyx_L42_unpacking_done:;
        }
        if (!(likely(PyList_CheckExact(__pyx_t_24))||((__pyx_t_24) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_24))) __PYX_ERR(0, 4344, __pyx_L1_error)
        __Pyx_DECREF_SET(__pyx_v_actual_asteroid_hit, __pyx_t_23);
        __pyx_t_23 = 0;
        __Pyx_DECREF_SET(__pyx_v_aiming_move_sequence, ((PyObject*)__pyx_t_24));
        __pyx_t_24 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid, __pyx_t_19);
        __pyx_t_19 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid_shooting_angle_error_deg, __pyx_t_7);
        __pyx_t_7 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid_interception_time_s, __pyx_t_1);
        __pyx_t_1 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid_turning_timesteps, __pyx_t_22);
        __pyx_t_22 = 0;
        __Pyx_XDECREF_SET(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_21);
        __pyx_t_21 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_state_after_aiming, __pyx_t_3);
        __pyx_t_3 = 0;

+4345:                     if actual_asteroid_hit is not None:

        __pyx_t_11 = (__pyx_v_actual_asteroid_hit != Py_None);
        if (__pyx_t_11) {
/* … */
        }

 4346:                         # We can hit the target

+4347:                         assert timesteps_until_bullet_hit_asteroid is not None

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_11 = (__pyx_v_timesteps_until_bullet_hit_asteroid != Py_None);
            if (unlikely(!__pyx_t_11)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 4347, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 4347, __pyx_L1_error)
          #endif

+4348:                         len_aiming_move_sequence = len(aiming_move_sequence)

          if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
            PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
            __PYX_ERR(0, 4348, __pyx_L1_error)
          }
          __pyx_t_15 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4348, __pyx_L1_error)
          __pyx_t_6 = PyLong_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4348, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_XDECREF_SET(__pyx_v_len_aiming_move_sequence, __pyx_t_6);
          __pyx_t_6 = 0;

+4349:                         actual_asteroid_hit_when_firing = time_travel_asteroid(actual_asteroid_hit, len_aiming_move_sequence - timesteps_until_bullet_hit_asteroid, self.game_state)

          __pyx_t_3 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4349, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_22 = PyNumber_Subtract(__pyx_v_len_aiming_move_sequence, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4349, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4349, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_21))) {
            __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_21);
            assert(__pyx_t_3);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21);
            __Pyx_INCREF(__pyx_t_3);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_21, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_v_actual_asteroid_hit, __pyx_t_22, __pyx_t_1};
            __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4349, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __Pyx_XDECREF_SET(__pyx_v_actual_asteroid_hit_when_firing, __pyx_t_6);
          __pyx_t_6 = 0;

+4350:                         if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len_aiming_move_sequence, self.game_state, actual_asteroid_hit_when_firing):

          __pyx_t_21 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_19 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_7 = PyNumber_Add(__pyx_t_19, __pyx_v_len_aiming_move_sequence); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_1))) {
            __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_1);
            assert(__pyx_t_21);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
            __Pyx_INCREF(__pyx_t_21);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[5] = {__pyx_t_21, __pyx_t_22, __pyx_t_7, __pyx_t_19, __pyx_v_actual_asteroid_hit_when_firing};
            __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4350, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4350, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (__pyx_t_11) {
/* … */
          }

 4351:                             # We haven't already shot at the target. This is good, so let's use it. Break out of the loop and don't check any more asteroids.

+4352:                             break

            goto __pyx_L37_break;

 4353:                 else:

 4354:                     # Between now and when I can shoot, I don't have enough time to aim at the imminent asteroid.

 4355:                     # Instead, find the closest asteroid along the way to shoot

 4356:                     # Sort by angular distance, with the unlikely tie broken by shot size

+4357:                     sorted_targets = target_asteroids_list

      /*else*/ {
        __Pyx_INCREF(__pyx_v_target_asteroids_list);
        __Pyx_XDECREF_SET(__pyx_v_sorted_targets, __pyx_v_target_asteroids_list);

+4358:                     sorted_targets.sort(key=lambda t: (round(t.shooting_angle_error_deg), ASTEROID_SIZE_SHOT_PRIORITY[t.asteroid.size]))

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_4lambda9(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_16target_selection_4lambda9 = {"lambda9", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_16target_selection_4lambda9, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_4lambda9(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_t = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda9 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_t,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4358, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4358, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda9", 0) < 0) __PYX_ERR(0, 4358, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda9", 1, 1, 1, i); __PYX_ERR(0, 4358, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4358, __pyx_L3_error)
    }
    __pyx_v_t = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("lambda9", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4358, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda9", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_lambda_funcdef_lambda9(__pyx_self, __pyx_v_t);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_lambda_funcdef_lambda9(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_t) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_round);
  __pyx_t_3 = __pyx_builtin_round; 
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4358, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROID_SIZE_SHOT_PRIORITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 4358, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 4358, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda9", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
        __pyx_t_1 = __pyx_v_sorted_targets;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_16target_selection_4lambda9, 0, __pyx_mstate_global->__pyx_n_u_Matrix_target_selection_locals_l, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4358, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __pyx_t_10 = 0;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, NULL};
          __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4358, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_19, __pyx_t_7, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4358, __pyx_L1_error)
          __pyx_t_6 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4358, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
        }
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 4359:                     # debug_print(f"Turn angle deg until we can fire (max 18 degrees): {turn_angle_deg_until_can_fire}")

+4360:                     if most_imminent_asteroid_shooting_angle_error_deg > 0.0:

        __pyx_t_6 = PyObject_RichCompare(__pyx_v_most_imminent_asteroid_shooting_angle_error_deg, __pyx_mstate_global->__pyx_float_0_0, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4360, __pyx_L1_error)
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4360, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (__pyx_t_11) {
/* … */
          goto __pyx_L45;
        }

 4361:                         # debug_print("The imminent shot requires us to turn the ship to the left")

+4362:                         target = self.find_extreme_shooting_angle_error(sorted_targets, turn_angle_deg_until_can_fire, 'largest_below')

          __pyx_t_7 = __pyx_cur_scope->__pyx_v_self;
          __Pyx_INCREF(__pyx_t_7);
          __pyx_t_10 = 0;
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_v_sorted_targets, __pyx_v_turn_angle_deg_until_can_fire, __pyx_mstate_global->__pyx_n_u_largest_below};
            __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_find_extreme_shooting_angle_erro, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4362, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __Pyx_XDECREF_SET(__pyx_v_target, __pyx_t_6);
          __pyx_t_6 = 0;

+4363:                         if target is None or target.shooting_angle_error_deg < 0.0 or target.shooting_angle_error_deg < turn_angle_deg_until_can_fire - TARGETING_AIMING_UNDERTURN_ALLOWANCE_DEG:

          __pyx_t_17 = (__pyx_v_target == Py_None);
          if (!__pyx_t_17) {
          } else {
            __pyx_t_11 = __pyx_t_17;
            goto __pyx_L47_bool_binop_done;
          }
          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (!__pyx_t_17) {
          } else {
            __pyx_t_11 = __pyx_t_17;
            goto __pyx_L47_bool_binop_done;
          }
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_TARGETING_AIMING_UNDERTURN_ALLOW); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_19 = PyNumber_Subtract(__pyx_v_turn_angle_deg_until_can_fire, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_t_19, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4363, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_11 = __pyx_t_17;
          __pyx_L47_bool_binop_done:;
          if (__pyx_t_11) {
/* … */
          }

 4364:                             # We're underturning too much, so instead find the next overturn

 4365:                             # debug_print("Underturning too much, so instead find the next overturn to the left")

+4366:                             target = self.find_extreme_shooting_angle_error(sorted_targets, turn_angle_deg_until_can_fire, 'smallest_above')

            __pyx_t_19 = __pyx_cur_scope->__pyx_v_self;
            __Pyx_INCREF(__pyx_t_19);
            __pyx_t_10 = 0;
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_19, __pyx_v_sorted_targets, __pyx_v_turn_angle_deg_until_can_fire, __pyx_mstate_global->__pyx_n_u_smallest_above};
              __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_find_extreme_shooting_angle_erro, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
              if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4366, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_6);
            }
            __Pyx_DECREF_SET(__pyx_v_target, __pyx_t_6);
            __pyx_t_6 = 0;

 4367:                     else:

 4368:                         # debug_print("The imminent shot requires us to turn the ship to the right")

+4369:                         target = self.find_extreme_shooting_angle_error(sorted_targets, -turn_angle_deg_until_can_fire, 'smallest_above')

        /*else*/ {
          __pyx_t_19 = __pyx_cur_scope->__pyx_v_self;
          __Pyx_INCREF(__pyx_t_19);
          __pyx_t_7 = PyNumber_Negative(__pyx_v_turn_angle_deg_until_can_fire); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_10 = 0;
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_19, __pyx_v_sorted_targets, __pyx_t_7, __pyx_mstate_global->__pyx_n_u_smallest_above};
            __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_find_extreme_shooting_angle_erro, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4369, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __Pyx_XDECREF_SET(__pyx_v_target, __pyx_t_6);
          __pyx_t_6 = 0;

 4370:                         # print("Found the next target to the right:")

 4371:                         # print(target)

+4372:                         if target is None or target.shooting_angle_error_deg > 0.0 or target.shooting_angle_error_deg > -turn_angle_deg_until_can_fire + TARGETING_AIMING_UNDERTURN_ALLOWANCE_DEG:

          __pyx_t_17 = (__pyx_v_target == Py_None);
          if (!__pyx_t_17) {
          } else {
            __pyx_t_11 = __pyx_t_17;
            goto __pyx_L51_bool_binop_done;
          }
          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_mstate_global->__pyx_float_0_0, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (!__pyx_t_17) {
          } else {
            __pyx_t_11 = __pyx_t_17;
            goto __pyx_L51_bool_binop_done;
          }
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_6 = PyNumber_Negative(__pyx_v_turn_angle_deg_until_can_fire); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_TARGETING_AIMING_UNDERTURN_ALLOW); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_1 = PyNumber_Add(__pyx_t_6, __pyx_t_19); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_19 = PyObject_RichCompare(__pyx_t_7, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4372, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __pyx_t_11 = __pyx_t_17;
          __pyx_L51_bool_binop_done:;
          if (__pyx_t_11) {
/* … */
          }
        }
        __pyx_L45:;

 4373:                             # We're underturning too much, so instead find the next overturn

 4374:                             # debug_print("Underturning too much, so instead find the next overturn to the right")

+4375:                             target = self.find_extreme_shooting_angle_error(sorted_targets, -turn_angle_deg_until_can_fire, 'largest_below')

            __pyx_t_1 = __pyx_cur_scope->__pyx_v_self;
            __Pyx_INCREF(__pyx_t_1);
            __pyx_t_7 = PyNumber_Negative(__pyx_v_turn_angle_deg_until_can_fire); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4375, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
            __pyx_t_10 = 0;
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_1, __pyx_v_sorted_targets, __pyx_t_7, __pyx_mstate_global->__pyx_n_u_largest_below};
              __pyx_t_19 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_find_extreme_shooting_angle_erro, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
              if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4375, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_19);
            }
            __Pyx_DECREF_SET(__pyx_v_target, __pyx_t_19);
            __pyx_t_19 = 0;

 4376:                             # print(target)

+4377:                     if target is not None:

        __pyx_t_11 = (__pyx_v_target != Py_None);
        if (__pyx_t_11) {
/* … */
          goto __pyx_L54;
        }

 4378:                         # debug_print('As our target were choosing this one which will be on our way:')

 4379:                         # debug_print(target)

+4380:                         actual_asteroid_hit, aiming_move_sequence, target_asteroid, target_asteroid_shooting_angle_error_deg, target_asteroid_interception_time_s, target_asteroid_turning_timesteps, timesteps_until_bullet_hit_asteroid, ship_state_after_aiming = simulate_shooting_at_target(target.asteroid, target.shooting_angle_error_deg, target.interception_time_s, target.aiming_timesteps_required)

          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          if (!(likely(((__pyx_t_19) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_19, __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid))))) __PYX_ERR(0, 4380, __pyx_L1_error)
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_29 = __Pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_29 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_interception_time_s); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_27 = __Pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_target, __pyx_mstate_global->__pyx_n_u_aiming_timesteps_required); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          if (!(likely(PyLong_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_7))) __PYX_ERR(0, 4380, __pyx_L1_error)
          __pyx_t_1 = __pyx_pf_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target(__pyx_v_simulate_shooting_at_target, ((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_t_19), __pyx_t_29, __pyx_t_27, ((PyObject*)__pyx_t_7)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
            PyObject* sequence = __pyx_t_1;
            Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
            if (unlikely(size != 8)) {
              if (size > 8) __Pyx_RaiseTooManyValuesError(8);
              else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
              __PYX_ERR(0, 4380, __pyx_L1_error)
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            if (likely(PyTuple_CheckExact(sequence))) {
              __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
              __Pyx_INCREF(__pyx_t_7);
              __pyx_t_19 = PyTuple_GET_ITEM(sequence, 1);
              __Pyx_INCREF(__pyx_t_19);
              __pyx_t_6 = PyTuple_GET_ITEM(sequence, 2);
              __Pyx_INCREF(__pyx_t_6);
              __pyx_t_22 = PyTuple_GET_ITEM(sequence, 3);
              __Pyx_INCREF(__pyx_t_22);
              __pyx_t_21 = PyTuple_GET_ITEM(sequence, 4);
              __Pyx_INCREF(__pyx_t_21);
              __pyx_t_3 = PyTuple_GET_ITEM(sequence, 5);
              __Pyx_INCREF(__pyx_t_3);
              __pyx_t_24 = PyTuple_GET_ITEM(sequence, 6);
              __Pyx_INCREF(__pyx_t_24);
              __pyx_t_23 = PyTuple_GET_ITEM(sequence, 7);
              __Pyx_INCREF(__pyx_t_23);
            } else {
              __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0);
              if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_7);
              __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 1);
              if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_19);
              __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 2);
              if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_6);
              __pyx_t_22 = __Pyx_PyList_GetItemRef(sequence, 3);
              if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_22);
              __pyx_t_21 = __Pyx_PyList_GetItemRef(sequence, 4);
              if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_21);
              __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 5);
              if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_3);
              __pyx_t_24 = __Pyx_PyList_GetItemRef(sequence, 6);
              if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_24);
              __pyx_t_23 = __Pyx_PyList_GetItemRef(sequence, 7);
              if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4380, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_23);
            }
            #else
            {
              Py_ssize_t i;
              PyObject** temps[8] = {&__pyx_t_7,&__pyx_t_19,&__pyx_t_6,&__pyx_t_22,&__pyx_t_21,&__pyx_t_3,&__pyx_t_24,&__pyx_t_23};
              for (i=0; i < 8; i++) {
                PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4380, __pyx_L1_error)
                __Pyx_GOTREF(item);
                *(temps[i]) = item;
              }
            }
            #endif
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          } else {
            Py_ssize_t index = -1;
            PyObject** temps[8] = {&__pyx_t_7,&__pyx_t_19,&__pyx_t_6,&__pyx_t_22,&__pyx_t_21,&__pyx_t_3,&__pyx_t_24,&__pyx_t_23};
            __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4380, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __pyx_t_20 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8);
            for (index=0; index < 8; index++) {
              PyObject* item = __pyx_t_20(__pyx_t_8); if (unlikely(!item)) goto __pyx_L55_unpacking_failed;
              __Pyx_GOTREF(item);
              *(temps[index]) = item;
            }
            if (__Pyx_IternextUnpackEndCheck(__pyx_t_20(__pyx_t_8), 8) < 0) __PYX_ERR(0, 4380, __pyx_L1_error)
            __pyx_t_20 = NULL;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            goto __pyx_L56_unpacking_done;
            __pyx_L55_unpacking_failed:;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_20 = NULL;
            if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
            __PYX_ERR(0, 4380, __pyx_L1_error)
            __pyx_L56_unpacking_done:;
          }
          if (!(likely(PyList_CheckExact(__pyx_t_19))||((__pyx_t_19) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_19))) __PYX_ERR(0, 4380, __pyx_L1_error)
          __Pyx_DECREF_SET(__pyx_v_actual_asteroid_hit, __pyx_t_7);
          __pyx_t_7 = 0;
          __Pyx_DECREF_SET(__pyx_v_aiming_move_sequence, ((PyObject*)__pyx_t_19));
          __pyx_t_19 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid, __pyx_t_6);
          __pyx_t_6 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid_shooting_angle_error_deg, __pyx_t_22);
          __pyx_t_22 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid_interception_time_s, __pyx_t_21);
          __pyx_t_21 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid_turning_timesteps, __pyx_t_3);
          __pyx_t_3 = 0;
          __Pyx_XDECREF_SET(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_24);
          __pyx_t_24 = 0;
          __Pyx_XDECREF_SET(__pyx_v_ship_state_after_aiming, __pyx_t_23);
          __pyx_t_23 = 0;

+4381:                         if actual_asteroid_hit is not None:

          __pyx_t_11 = (__pyx_v_actual_asteroid_hit != Py_None);
          if (__pyx_t_11) {
/* … */
          }

+4382:                             assert timesteps_until_bullet_hit_asteroid is not None

            #ifndef CYTHON_WITHOUT_ASSERTIONS
            if (unlikely(__pyx_assertions_enabled())) {
              __pyx_t_11 = (__pyx_v_timesteps_until_bullet_hit_asteroid != Py_None);
              if (unlikely(!__pyx_t_11)) {
                __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
                __PYX_ERR(0, 4382, __pyx_L1_error)
              }
            }
            #else
            if ((1)); else __PYX_ERR(0, 4382, __pyx_L1_error)
            #endif

+4383:                             len_aiming_move_sequence = len(aiming_move_sequence)

            if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
              __PYX_ERR(0, 4383, __pyx_L1_error)
            }
            __pyx_t_15 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4383, __pyx_L1_error)
            __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4383, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_XDECREF_SET(__pyx_v_len_aiming_move_sequence, __pyx_t_1);
            __pyx_t_1 = 0;

+4384:                             actual_asteroid_hit_when_firing = time_travel_asteroid(actual_asteroid_hit, len_aiming_move_sequence - timesteps_until_bullet_hit_asteroid, self.game_state)

            __pyx_t_23 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_24, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4384, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_24);
            __pyx_t_3 = PyNumber_Subtract(__pyx_v_len_aiming_move_sequence, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4384, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4384, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_21);
            __pyx_t_10 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_24))) {
              __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_24);
              assert(__pyx_t_23);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_24);
              __Pyx_INCREF(__pyx_t_23);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_24, __pyx__function);
              __pyx_t_10 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_23, __pyx_v_actual_asteroid_hit, __pyx_t_3, __pyx_t_21};
              __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_24, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
              __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
              if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4384, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
            }
            __Pyx_XDECREF_SET(__pyx_v_actual_asteroid_hit_when_firing, __pyx_t_1);
            __pyx_t_1 = 0;

+4385:                             if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len_aiming_move_sequence, self.game_state, actual_asteroid_hit_when_firing):

            __pyx_t_24 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_21);
            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_23);
            __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_22);
            __pyx_t_6 = PyNumber_Add(__pyx_t_23, __pyx_t_22); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __pyx_t_22 = PyNumber_Add(__pyx_t_6, __pyx_v_len_aiming_move_sequence); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_22);
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            __pyx_t_10 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_21))) {
              __pyx_t_24 = PyMethod_GET_SELF(__pyx_t_21);
              assert(__pyx_t_24);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21);
              __Pyx_INCREF(__pyx_t_24);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_21, __pyx__function);
              __pyx_t_10 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[5] = {__pyx_t_24, __pyx_t_3, __pyx_t_22, __pyx_t_6, __pyx_v_actual_asteroid_hit_when_firing};
              __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
              if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4385, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
            }
            __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4385, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (__pyx_t_11) {
/* … */
            }

+4386:                                 break

              goto __pyx_L37_break;

 4387:                         #    print(f"DANG IT, we're shooting something on the way to the most imminent asteroid, but we'll miss this particular one!")

 4388:                     else:

 4389:                         # Just gonna have to waste shot opportunities and turn all the way

+4390:                         actual_asteroid_hit, aiming_move_sequence, target_asteroid, target_asteroid_shooting_angle_error_deg, target_asteroid_interception_time_s, target_asteroid_turning_timesteps, timesteps_until_bullet_hit_asteroid, ship_state_after_aiming = simulate_shooting_at_target(most_imminent_asteroid, most_imminent_asteroid_shooting_angle_error_deg, most_imminent_asteroid_interception_time_s, most_imminent_asteroid_aiming_timesteps)

        /*else*/ {
          if (!(likely(((__pyx_v_most_imminent_asteroid) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_most_imminent_asteroid, __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid))))) __PYX_ERR(0, 4390, __pyx_L1_error)
          __pyx_t_27 = __Pyx_PyFloat_AsDouble(__pyx_v_most_imminent_asteroid_shooting_angle_error_deg); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4390, __pyx_L1_error)
          __pyx_t_29 = __Pyx_PyFloat_AsDouble(__pyx_v_most_imminent_asteroid_interception_time_s); if (unlikely((__pyx_t_29 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4390, __pyx_L1_error)
          if (!(likely(PyLong_CheckExact(__pyx_v_most_imminent_asteroid_aiming_timesteps))||((__pyx_v_most_imminent_asteroid_aiming_timesteps) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_v_most_imminent_asteroid_aiming_timesteps))) __PYX_ERR(0, 4390, __pyx_L1_error)
          __pyx_t_1 = __pyx_pf_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target(__pyx_v_simulate_shooting_at_target, ((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_most_imminent_asteroid), __pyx_t_27, __pyx_t_29, ((PyObject*)__pyx_v_most_imminent_asteroid_aiming_timesteps)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4390, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
            PyObject* sequence = __pyx_t_1;
            Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
            if (unlikely(size != 8)) {
              if (size > 8) __Pyx_RaiseTooManyValuesError(8);
              else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
              __PYX_ERR(0, 4390, __pyx_L1_error)
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            if (likely(PyTuple_CheckExact(sequence))) {
              __pyx_t_21 = PyTuple_GET_ITEM(sequence, 0);
              __Pyx_INCREF(__pyx_t_21);
              __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
              __Pyx_INCREF(__pyx_t_6);
              __pyx_t_22 = PyTuple_GET_ITEM(sequence, 2);
              __Pyx_INCREF(__pyx_t_22);
              __pyx_t_3 = PyTuple_GET_ITEM(sequence, 3);
              __Pyx_INCREF(__pyx_t_3);
              __pyx_t_24 = PyTuple_GET_ITEM(sequence, 4);
              __Pyx_INCREF(__pyx_t_24);
              __pyx_t_23 = PyTuple_GET_ITEM(sequence, 5);
              __Pyx_INCREF(__pyx_t_23);
              __pyx_t_19 = PyTuple_GET_ITEM(sequence, 6);
              __Pyx_INCREF(__pyx_t_19);
              __pyx_t_7 = PyTuple_GET_ITEM(sequence, 7);
              __Pyx_INCREF(__pyx_t_7);
            } else {
              __pyx_t_21 = __Pyx_PyList_GetItemRef(sequence, 0);
              if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_21);
              __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1);
              if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_6);
              __pyx_t_22 = __Pyx_PyList_GetItemRef(sequence, 2);
              if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_22);
              __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 3);
              if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_3);
              __pyx_t_24 = __Pyx_PyList_GetItemRef(sequence, 4);
              if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_24);
              __pyx_t_23 = __Pyx_PyList_GetItemRef(sequence, 5);
              if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_23);
              __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 6);
              if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_19);
              __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 7);
              if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4390, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_7);
            }
            #else
            {
              Py_ssize_t i;
              PyObject** temps[8] = {&__pyx_t_21,&__pyx_t_6,&__pyx_t_22,&__pyx_t_3,&__pyx_t_24,&__pyx_t_23,&__pyx_t_19,&__pyx_t_7};
              for (i=0; i < 8; i++) {
                PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4390, __pyx_L1_error)
                __Pyx_GOTREF(item);
                *(temps[i]) = item;
              }
            }
            #endif
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          } else {
            Py_ssize_t index = -1;
            PyObject** temps[8] = {&__pyx_t_21,&__pyx_t_6,&__pyx_t_22,&__pyx_t_3,&__pyx_t_24,&__pyx_t_23,&__pyx_t_19,&__pyx_t_7};
            __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4390, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __pyx_t_20 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8);
            for (index=0; index < 8; index++) {
              PyObject* item = __pyx_t_20(__pyx_t_8); if (unlikely(!item)) goto __pyx_L59_unpacking_failed;
              __Pyx_GOTREF(item);
              *(temps[index]) = item;
            }
            if (__Pyx_IternextUnpackEndCheck(__pyx_t_20(__pyx_t_8), 8) < 0) __PYX_ERR(0, 4390, __pyx_L1_error)
            __pyx_t_20 = NULL;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            goto __pyx_L60_unpacking_done;
            __pyx_L59_unpacking_failed:;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_20 = NULL;
            if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
            __PYX_ERR(0, 4390, __pyx_L1_error)
            __pyx_L60_unpacking_done:;
          }
          if (!(likely(PyList_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_6))) __PYX_ERR(0, 4390, __pyx_L1_error)
          __Pyx_DECREF_SET(__pyx_v_actual_asteroid_hit, __pyx_t_21);
          __pyx_t_21 = 0;
          __Pyx_DECREF_SET(__pyx_v_aiming_move_sequence, ((PyObject*)__pyx_t_6));
          __pyx_t_6 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid, __pyx_t_22);
          __pyx_t_22 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid_shooting_angle_error_deg, __pyx_t_3);
          __pyx_t_3 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid_interception_time_s, __pyx_t_24);
          __pyx_t_24 = 0;
          __Pyx_XDECREF_SET(__pyx_v_target_asteroid_turning_timesteps, __pyx_t_23);
          __pyx_t_23 = 0;
          __Pyx_XDECREF_SET(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_19);
          __pyx_t_19 = 0;
          __Pyx_XDECREF_SET(__pyx_v_ship_state_after_aiming, __pyx_t_7);
          __pyx_t_7 = 0;

+4391:                         if actual_asteroid_hit is not None:

          __pyx_t_11 = (__pyx_v_actual_asteroid_hit != Py_None);
          if (__pyx_t_11) {
/* … */
          }
        }
        __pyx_L54:;
      }
      __pyx_L39:;

+4392:                             assert timesteps_until_bullet_hit_asteroid is not None

            #ifndef CYTHON_WITHOUT_ASSERTIONS
            if (unlikely(__pyx_assertions_enabled())) {
              __pyx_t_11 = (__pyx_v_timesteps_until_bullet_hit_asteroid != Py_None);
              if (unlikely(!__pyx_t_11)) {
                __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
                __PYX_ERR(0, 4392, __pyx_L1_error)
              }
            }
            #else
            if ((1)); else __PYX_ERR(0, 4392, __pyx_L1_error)
            #endif

+4393:                             len_aiming_move_sequence = len(aiming_move_sequence)

            if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
              __PYX_ERR(0, 4393, __pyx_L1_error)
            }
            __pyx_t_15 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4393, __pyx_L1_error)
            __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4393, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_XDECREF_SET(__pyx_v_len_aiming_move_sequence, __pyx_t_1);
            __pyx_t_1 = 0;

+4394:                             actual_asteroid_hit_when_firing = time_travel_asteroid(actual_asteroid_hit, len_aiming_move_sequence - timesteps_until_bullet_hit_asteroid, self.game_state)

            __pyx_t_7 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4394, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_19);
            __pyx_t_23 = PyNumber_Subtract(__pyx_v_len_aiming_move_sequence, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4394, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_23);
            __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4394, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_24);
            __pyx_t_10 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_19))) {
              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_19);
              assert(__pyx_t_7);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19);
              __Pyx_INCREF(__pyx_t_7);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_19, __pyx__function);
              __pyx_t_10 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_v_actual_asteroid_hit, __pyx_t_23, __pyx_t_24};
              __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
              __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
              __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
              if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4394, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
            }
            __Pyx_XDECREF_SET(__pyx_v_actual_asteroid_hit_when_firing, __pyx_t_1);
            __pyx_t_1 = 0;

+4395:                             if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len_aiming_move_sequence, self.game_state, actual_asteroid_hit_when_firing):

            __pyx_t_19 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_24, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_24);
            __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_23);
            __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_22 = PyNumber_Add(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_22);
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_3 = PyNumber_Add(__pyx_t_22, __pyx_v_len_aiming_move_sequence); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_22);
            __pyx_t_10 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_24))) {
              __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_24);
              assert(__pyx_t_19);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_24);
              __Pyx_INCREF(__pyx_t_19);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_24, __pyx__function);
              __pyx_t_10 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[5] = {__pyx_t_19, __pyx_t_23, __pyx_t_3, __pyx_t_22, __pyx_v_actual_asteroid_hit_when_firing};
              __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_24, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
              __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
              __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
              if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4395, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
            }
            __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4395, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (__pyx_t_11) {
/* … */
            }

+4396:                                 break

              goto __pyx_L37_break;

 4397:             #if actual_asteroid_hit:

 4398:             #    self.explanation_messages.append("Shooting at asteroid on a collision course with me.")

+4399:         if not actual_asteroid_hit:

  __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_actual_asteroid_hit); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4399, __pyx_L1_error)
  __pyx_t_17 = (!__pyx_t_11);
  if (__pyx_t_17) {
/* … */
  }

 4400:             # Nothing has been hit from the imminent shots so far. Either no imminent asteroids exist, or we tried (simulated) hitting some but we missed them all.

 4401:             # Move down the list to trying for convenient shots.

+4402:             if target_asteroids_list:

    __pyx_t_17 = (__Pyx_PyList_GET_SIZE(__pyx_v_target_asteroids_list) != 0);
    if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_17 < 0))) __PYX_ERR(0, 4402, __pyx_L1_error)
    if (__pyx_t_17) {
/* … */
      goto __pyx_L65;
    }

+4403:                 self.explanation_messages.append("No asteroids on collision course with me. Shooting at asteroids with least turning delay.")

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4403, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_No_asteroids_on_collision_course); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(0, 4403, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4404:                 sorted_targets = target_asteroids_list

      __Pyx_INCREF(__pyx_v_target_asteroids_list);
      __Pyx_XDECREF_SET(__pyx_v_sorted_targets, __pyx_v_target_asteroids_list);

+4405:                 if self.other_ships:

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4405, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4405, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (__pyx_t_17) {
/* … */
        goto __pyx_L66;
      }

 4406:                     # If there's a bullet limit, penalize risky shots more

+4407:                     frontrun_score_multiplier = 25.0 if self.ship_state.bullets_remaining > 0 else 15.0

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4407, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4407, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyObject_RichCompare(__pyx_t_25, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4407, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4407, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (__pyx_t_17) {
          __pyx_t_29 = 25.0;
        } else {
          __pyx_t_29 = 15.0;
        }
        __pyx_cur_scope->__pyx_v_frontrun_score_multiplier = __pyx_t_29;

 4408:                     # Sort by just convenience (and anything else I'd like)

+4409:                     sorted_targets.sort(key=lambda t: (

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_5lambda10(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_16target_selection_5lambda10 = {"lambda10", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_16target_selection_5lambda10, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_5lambda10(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_t = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda10 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_t,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4409, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4409, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda10", 0) < 0) __PYX_ERR(0, 4409, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda10", 1, 1, 1, i); __PYX_ERR(0, 4409, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4409, __pyx_L3_error)
    }
    __pyx_v_t = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("lambda10", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4409, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda10", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_lambda_funcdef_lambda10(__pyx_self, __pyx_v_t);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_lambda_funcdef_lambda10(PyObject *__pyx_self, PyObject *__pyx_v_t) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *__pyx_cur_scope;
  struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *__pyx_outer_scope;
  PyObject *__pyx_r = NULL;
  __pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_13_target_selection *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __pyx_cur_scope = __pyx_outer_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda10", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
        __pyx_t_25 = __pyx_v_sorted_targets;
        __Pyx_INCREF(__pyx_t_25);
        __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_16target_selection_5lambda10, 0, __pyx_mstate_global->__pyx_n_u_Matrix_target_selection_locals_l, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4409, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_10 = 0;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_25, NULL};
          __pyx_t_24 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4409, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_24);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_1, __pyx_t_24, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4409, __pyx_L1_error)
          __pyx_t_9 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_24);
          __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4409, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4410:                         float(t.aiming_timesteps_required)*2.0 +

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_aiming_timesteps_required); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_2 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4410, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble((__pyx_t_2 * 2.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
/* … */
  __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4410, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4411:                         ASTEROID_SIZE_SHOT_PRIORITY[t.asteroid.size] +

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROID_SIZE_SHOT_PRIORITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4411, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4411, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4411, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4411, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
  __pyx_t_1 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4411, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4412:                         t.interception_time_s + # Might be more correct to do t.interception_time_s + t.aiming_timesteps_required*DELTA_TIME - get_adversary_interception_time_lower_bound(t.asteroid, self.other_ships, self.game_state)

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_interception_time_s); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4412, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
/* … */
  __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4412, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+4413:                         t.asteroid_dist_during_interception/400.0 +

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_dist_during_interceptio); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4413, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_float_400_0, 400.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4413, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4413, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+4414:                         frontrun_score_multiplier*min(0.5, max(0, t.interception_time_s - get_adversary_interception_time_lower_bound(t.asteroid, self.other_ships, self.game_state))) +

  __pyx_t_5 = PyFloat_FromDouble(__pyx_cur_scope->__pyx_v_frontrun_score_multiplier); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_interception_time_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_get_adversary_interception_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4414, __pyx_L1_error) }
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 4414, __pyx_L1_error) }
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_t_8, __pyx_t_9, __pyx_t_10};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4414, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_7 = PyNumber_Subtract(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_12 = 0;
  __pyx_t_1 = __Pyx_PyLong_From_long(__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_10 = PyObject_RichCompare(__pyx_t_7, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (__pyx_t_13) {
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_3 = __pyx_t_7;
  } else {
    __pyx_t_10 = __Pyx_PyLong_From_long(__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4414, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_3 = __pyx_t_10;
    __pyx_t_10 = 0;
  }
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_7 = __pyx_t_3;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_2 = 0.5;
  __pyx_t_10 = PyFloat_FromDouble(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_t_10, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_13) {
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_3 = __pyx_t_7;
  } else {
    __pyx_t_1 = PyFloat_FromDouble(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4414, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __pyx_t_1;
    __pyx_t_1 = 0;
  }
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4414, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+4415:                         ((20.0 if t.asteroid.size == 1 else -20.0) if t.asteroid_will_get_hit_by_my_mine else 0.0) +

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4415, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_13) {
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4415, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4415, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_14 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4415, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_14) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_20_0);
      __pyx_t_4 = __pyx_mstate_global->__pyx_float_20_0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_20_0);
      __pyx_t_4 = __pyx_mstate_global->__pyx_float_neg_20_0;
    }
    __pyx_t_7 = __pyx_t_4;
    __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_t_7 = __pyx_mstate_global->__pyx_float_0_0;
  }
/* … */
  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

+4416:                         ((20.0 if t.asteroid.size != 1 else -20.0) if t.asteroid_will_get_hit_by_their_mine else 0.0)

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_their_m); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4416, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4416, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_13) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_14 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4416, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_14) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_20_0);
      __pyx_t_3 = __pyx_mstate_global->__pyx_float_20_0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_20_0);
      __pyx_t_3 = __pyx_mstate_global->__pyx_float_neg_20_0;
    }
    __pyx_t_7 = __pyx_t_3;
    __pyx_t_3 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_t_7 = __pyx_mstate_global->__pyx_float_0_0;
  }

 4417:                     ))

 4418:                 else:

+4419:                     sorted_targets.sort(key=lambda t: (

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_6lambda11(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_16target_selection_6lambda11 = {"lambda11", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_16target_selection_6lambda11, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_16target_selection_6lambda11(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_t = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("lambda11 (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_t,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4419, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4419, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda11", 0) < 0) __PYX_ERR(0, 4419, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda11", 1, 1, 1, i); __PYX_ERR(0, 4419, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4419, __pyx_L3_error)
    }
    __pyx_v_t = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("lambda11", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4419, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda11", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_lambda_funcdef_lambda11(__pyx_self, __pyx_v_t);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_lambda_funcdef_lambda11(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_t) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.Matrix.target_selection.lambda11", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
      /*else*/ {
        __pyx_t_24 = __pyx_v_sorted_targets;
        __Pyx_INCREF(__pyx_t_24);
        __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_16target_selection_6lambda11, 0, __pyx_mstate_global->__pyx_n_u_Matrix_target_selection_locals_l, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4419, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_10 = 0;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_24, NULL};
          __pyx_t_25 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4419, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_1, __pyx_t_25, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4419, __pyx_L1_error)
          __pyx_t_9 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_25);
          __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4419, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      }
      __pyx_L66:;

+4420:                         float(t.aiming_timesteps_required)*2.0 +

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_aiming_timesteps_required); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_2 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4420, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble((__pyx_t_2 * 2.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
/* … */
  __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+4421:                         ASTEROID_SIZE_SHOT_PRIORITY[t.asteroid.size] +

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ASTEROID_SIZE_SHOT_PRIORITY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+4422:                         t.asteroid_dist_during_interception/400.0 +

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_dist_during_interceptio); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_4, __pyx_mstate_global->__pyx_float_400_0, 400.0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
  __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

+4423:                         ((20.0 if t.asteroid.size == 1 else -20.0) if t.asteroid_will_get_hit_by_my_mine else 0.0)

  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid_will_get_hit_by_my_mine); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4423, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_6) {
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4423, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4423, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_8 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 4423, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_8) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_20_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_float_20_0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_neg_20_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_float_neg_20_0;
    }
    __pyx_t_1 = __pyx_t_5;
    __pyx_t_5 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __pyx_t_1 = __pyx_mstate_global->__pyx_float_0_0;
  }

 4424:                     ))

+4425:                 for confirmed_target in sorted_targets:

      __pyx_t_9 = __pyx_v_sorted_targets; __Pyx_INCREF(__pyx_t_9);
      __pyx_t_13 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4425, __pyx_L1_error)
          #endif
          if (__pyx_t_13 >= __pyx_temp) break;
        }
        __pyx_t_25 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_13);
        ++__pyx_t_13;
        if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4425, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_XDECREF_SET(__pyx_v_confirmed_target, __pyx_t_25);
        __pyx_t_25 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      goto __pyx_L73_for_end;
      __pyx_L68_break:;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      goto __pyx_L73_for_end;
      __pyx_L73_for_end:;

+4426:                     least_shot_delay_asteroid = confirmed_target.asteroid

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_confirmed_target, __pyx_mstate_global->__pyx_n_u_asteroid); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4426, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_XDECREF_SET(__pyx_v_least_shot_delay_asteroid, __pyx_t_25);
        __pyx_t_25 = 0;

+4427:                     least_shot_delay_asteroid_shooting_angle_error_deg = confirmed_target.shooting_angle_error_deg

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_confirmed_target, __pyx_mstate_global->__pyx_n_u_shooting_angle_error_deg); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4427, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_XDECREF_SET(__pyx_v_least_shot_delay_asteroid_shooting_angle_error_deg, __pyx_t_25);
        __pyx_t_25 = 0;

+4428:                     least_shot_delay_asteroid_interception_time_s = confirmed_target.interception_time_s

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_confirmed_target, __pyx_mstate_global->__pyx_n_u_interception_time_s); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4428, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_XDECREF_SET(__pyx_v_least_shot_delay_asteroid_interception_time_s, __pyx_t_25);
        __pyx_t_25 = 0;

+4429:                     least_shot_delay_asteroid_aiming_timesteps = confirmed_target.aiming_timesteps_required

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_confirmed_target, __pyx_mstate_global->__pyx_n_u_aiming_timesteps_required); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4429, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_XDECREF_SET(__pyx_v_least_shot_delay_asteroid_aiming_timesteps, __pyx_t_25);
        __pyx_t_25 = 0;

 4430:                     #least_shot_delay_asteroid = cast(Asteroid, least_shot_delay_asteroid)

 4431:                     #assert isinstance(least_shot_delay_asteroid_shooting_angle_error_deg, float)

 4432:                     #assert isinstance(least_shot_delay_asteroid_interception_time_s, float)

 4433:                     #assert isinstance(least_shot_delay_asteroid_aiming_timesteps, int)

+4434:                     actual_asteroid_hit, aiming_move_sequence, target_asteroid, target_asteroid_shooting_angle_error_deg, target_asteroid_interception_time_s, target_asteroid_turning_timesteps, timesteps_until_bullet_hit_asteroid, ship_state_after_aiming = simulate_shooting_at_target(least_shot_delay_asteroid, least_shot_delay_asteroid_shooting_angle_error_deg, least_shot_delay_asteroid_interception_time_s, least_shot_delay_asteroid_aiming_timesteps)

        if (!(likely(((__pyx_v_least_shot_delay_asteroid) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_least_shot_delay_asteroid, __pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid))))) __PYX_ERR(0, 4434, __pyx_L1_error)
        __pyx_t_29 = __Pyx_PyFloat_AsDouble(__pyx_v_least_shot_delay_asteroid_shooting_angle_error_deg); if (unlikely((__pyx_t_29 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4434, __pyx_L1_error)
        __pyx_t_27 = __Pyx_PyFloat_AsDouble(__pyx_v_least_shot_delay_asteroid_interception_time_s); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4434, __pyx_L1_error)
        if (!(likely(PyLong_CheckExact(__pyx_v_least_shot_delay_asteroid_aiming_timesteps))||((__pyx_v_least_shot_delay_asteroid_aiming_timesteps) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_v_least_shot_delay_asteroid_aiming_timesteps))) __PYX_ERR(0, 4434, __pyx_L1_error)
        __pyx_t_25 = __pyx_pf_14neo_controller_6Matrix_16target_selection_simulate_shooting_at_target(__pyx_v_simulate_shooting_at_target, ((struct __pyx_obj_14neo_controller_Asteroid *)__pyx_v_least_shot_delay_asteroid), __pyx_t_29, __pyx_t_27, ((PyObject*)__pyx_v_least_shot_delay_asteroid_aiming_timesteps)); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4434, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        if ((likely(PyTuple_CheckExact(__pyx_t_25))) || (PyList_CheckExact(__pyx_t_25))) {
          PyObject* sequence = __pyx_t_25;
          Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
          if (unlikely(size != 8)) {
            if (size > 8) __Pyx_RaiseTooManyValuesError(8);
            else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
            __PYX_ERR(0, 4434, __pyx_L1_error)
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          if (likely(PyTuple_CheckExact(sequence))) {
            __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0);
            __Pyx_INCREF(__pyx_t_1);
            __pyx_t_24 = PyTuple_GET_ITEM(sequence, 1);
            __Pyx_INCREF(__pyx_t_24);
            __pyx_t_22 = PyTuple_GET_ITEM(sequence, 2);
            __Pyx_INCREF(__pyx_t_22);
            __pyx_t_3 = PyTuple_GET_ITEM(sequence, 3);
            __Pyx_INCREF(__pyx_t_3);
            __pyx_t_23 = PyTuple_GET_ITEM(sequence, 4);
            __Pyx_INCREF(__pyx_t_23);
            __pyx_t_19 = PyTuple_GET_ITEM(sequence, 5);
            __Pyx_INCREF(__pyx_t_19);
            __pyx_t_7 = PyTuple_GET_ITEM(sequence, 6);
            __Pyx_INCREF(__pyx_t_7);
            __pyx_t_6 = PyTuple_GET_ITEM(sequence, 7);
            __Pyx_INCREF(__pyx_t_6);
          } else {
            __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 0);
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_1);
            __pyx_t_24 = __Pyx_PyList_GetItemRef(sequence, 1);
            if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_24);
            __pyx_t_22 = __Pyx_PyList_GetItemRef(sequence, 2);
            if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_22);
            __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 3);
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_3);
            __pyx_t_23 = __Pyx_PyList_GetItemRef(sequence, 4);
            if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_23);
            __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 5);
            if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_19);
            __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 6);
            if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_7);
            __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 7);
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4434, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_6);
          }
          #else
          {
            Py_ssize_t i;
            PyObject** temps[8] = {&__pyx_t_1,&__pyx_t_24,&__pyx_t_22,&__pyx_t_3,&__pyx_t_23,&__pyx_t_19,&__pyx_t_7,&__pyx_t_6};
            for (i=0; i < 8; i++) {
              PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4434, __pyx_L1_error)
              __Pyx_GOTREF(item);
              *(temps[i]) = item;
            }
          }
          #endif
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        } else {
          Py_ssize_t index = -1;
          PyObject** temps[8] = {&__pyx_t_1,&__pyx_t_24,&__pyx_t_22,&__pyx_t_3,&__pyx_t_23,&__pyx_t_19,&__pyx_t_7,&__pyx_t_6};
          __pyx_t_21 = PyObject_GetIter(__pyx_t_25); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4434, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __pyx_t_20 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_21);
          for (index=0; index < 8; index++) {
            PyObject* item = __pyx_t_20(__pyx_t_21); if (unlikely(!item)) goto __pyx_L69_unpacking_failed;
            __Pyx_GOTREF(item);
            *(temps[index]) = item;
          }
          if (__Pyx_IternextUnpackEndCheck(__pyx_t_20(__pyx_t_21), 8) < 0) __PYX_ERR(0, 4434, __pyx_L1_error)
          __pyx_t_20 = NULL;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          goto __pyx_L70_unpacking_done;
          __pyx_L69_unpacking_failed:;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __pyx_t_20 = NULL;
          if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
          __PYX_ERR(0, 4434, __pyx_L1_error)
          __pyx_L70_unpacking_done:;
        }
        if (!(likely(PyList_CheckExact(__pyx_t_24))||((__pyx_t_24) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_24))) __PYX_ERR(0, 4434, __pyx_L1_error)
        __Pyx_DECREF_SET(__pyx_v_actual_asteroid_hit, __pyx_t_1);
        __pyx_t_1 = 0;
        __Pyx_DECREF_SET(__pyx_v_aiming_move_sequence, ((PyObject*)__pyx_t_24));
        __pyx_t_24 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid, __pyx_t_22);
        __pyx_t_22 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid_shooting_angle_error_deg, __pyx_t_3);
        __pyx_t_3 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid_interception_time_s, __pyx_t_23);
        __pyx_t_23 = 0;
        __Pyx_XDECREF_SET(__pyx_v_target_asteroid_turning_timesteps, __pyx_t_19);
        __pyx_t_19 = 0;
        __Pyx_XDECREF_SET(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_7);
        __pyx_t_7 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_state_after_aiming, __pyx_t_6);
        __pyx_t_6 = 0;

 4435:                     # actual_asteroid_hit is at the timestep (self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid)

 4436:                     # The timesteps_until_bullet_hit_asteroid time INCLUDES the aiming time!

 4437:                     # The reason we can't just check whether the asteroid in the future has a pending shot, and we have to back-extrapolate to when we fire, is that, say I do a shot at time 0, and it’ll hit the ast at time 10. If at time 8, I check whether I’ve shot at the asteroid already, and say it’ll take 5 timesteps to hit it. I need to check at time 8, NOT TIME 13! Time 13 is after the original shot hits it, so I can’t be checking it after. So THAT’S WHY I should be back-projecting the asteroid.

+4438:                     if actual_asteroid_hit is not None:

        __pyx_t_17 = (__pyx_v_actual_asteroid_hit != Py_None);
        if (__pyx_t_17) {
/* … */
        }

+4439:                         assert timesteps_until_bullet_hit_asteroid is not None

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_17 = (__pyx_v_timesteps_until_bullet_hit_asteroid != Py_None);
            if (unlikely(!__pyx_t_17)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 4439, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 4439, __pyx_L1_error)
          #endif

+4440:                         len_aiming_move_sequence = len(aiming_move_sequence)

          if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
            PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
            __PYX_ERR(0, 4440, __pyx_L1_error)
          }
          __pyx_t_15 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4440, __pyx_L1_error)
          __pyx_t_25 = PyLong_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4440, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __Pyx_XDECREF_SET(__pyx_v_len_aiming_move_sequence, __pyx_t_25);
          __pyx_t_25 = 0;

+4441:                         actual_asteroid_hit_when_firing = time_travel_asteroid(actual_asteroid_hit, len_aiming_move_sequence - timesteps_until_bullet_hit_asteroid, self.game_state)

          __pyx_t_6 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_19 = PyNumber_Subtract(__pyx_v_len_aiming_move_sequence, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_7))) {
            __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
            assert(__pyx_t_6);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
            __Pyx_INCREF(__pyx_t_6);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_v_actual_asteroid_hit, __pyx_t_19, __pyx_t_23};
            __pyx_t_25 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4441, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_25);
          }
          __Pyx_XDECREF_SET(__pyx_v_actual_asteroid_hit_when_firing, __pyx_t_25);
          __pyx_t_25 = 0;

+4442:                         if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len_aiming_move_sequence, self.game_state, actual_asteroid_hit_when_firing):  # , f"Dang it. {self.initial_timestep=}, {self.future_timesteps=}, actual_asteroid_hit_when_firing: {ast_to_string(actual_asteroid_hit_when_firing)}, {timesteps_until_bullet_hit_asteroid=}, {len(aiming_move_sequence)=}, self.asteroids_pending_death: {self.asteroids_pending_death}"

          __pyx_t_7 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_22 = PyNumber_Add(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_3 = PyNumber_Add(__pyx_t_22, __pyx_v_len_aiming_move_sequence); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_23))) {
            __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_23);
            assert(__pyx_t_7);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
            __Pyx_INCREF(__pyx_t_7);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[5] = {__pyx_t_7, __pyx_t_19, __pyx_t_3, __pyx_t_22, __pyx_v_actual_asteroid_hit_when_firing};
            __pyx_t_25 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4442, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_25);
          }
          __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4442, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          if (__pyx_t_17) {
/* … */
          }

+4443:                             break

            goto __pyx_L68_break;

 4444:             else:

 4445:                 # Ain't nothing to shoot at

 4446:                 # debug_print('Nothing to shoot at!')

+4447:                 self.explanation_messages.append("There's nothing I can feasibly shoot at!")

    /*else*/ {
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4447, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_There_s_nothing_I_can_feasibly_s); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(0, 4447, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 4448:                 # Pick a direction to turn the ship anyway, just to better line it up with more shots

+4449:                 if asteroids_still_exist:

      if (__pyx_v_asteroids_still_exist) {
/* … */
        goto __pyx_L74;
      }

+4450:                     if random.randint(1, 10) == 1:

        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4450, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_randint); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4450, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_25, __pyx_mstate_global->__pyx_tuple[25], NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4450, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_t_17 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4450, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (__pyx_t_17) {
/* … */
        }
/* … */
  __pyx_mstate_global->__pyx_tuple[25] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_10); if (unlikely(!__pyx_mstate_global->__pyx_tuple[25])) __PYX_ERR(0, 4450, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[25]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[25]);

+4451:                         self.explanation_messages.append("Asteroids exist but we can't hit them. Moving around a bit randomly.")

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4451, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_Asteroids_exist_but_we_can_t_hit); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(0, 4451, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 4452:                         # Setting this to -1 is a signal to set the asteroid fitness really low, so hopefully we'll choose actions that'll move around

+4453:                         self.asteroids_shot -= 1

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4453, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_25 = __Pyx_PyLong_SubtractObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4453, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_t_25) < 0) __PYX_ERR(0, 4453, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;

+4454:                     turn_direction = 0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __pyx_v_turn_direction = __pyx_mstate_global->__pyx_int_0;

+4455:                     idle_thrust = 0.0

        __pyx_v_idle_thrust = 0.0;

 4456:                 else:

+4457:                     self.explanation_messages.append("Asteroids no longer exist. We're all done!")

      /*else*/ {
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4457, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_25, __pyx_mstate_global->__pyx_kp_u_Asteroids_no_longer_exist_We_re); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(0, 4457, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;

 4458:                     #self.explanation_messages.append(f"In this scenario, I have simulated {total_sim_timesteps*DELTA_TIME/60:0.0f} minutes of gameplay! Bullet sim took {bullet_sim_time} s and the sim update took {sim_update_total_time} s with the sim culling taking {sim_cull_total_time} s, unwrapping taking {unwrap_total_time} s, and culling asteroids_pending_death is {asteroids_pending_death_total_cull_time} s, {asteroid_tracking_total_time=}, {asteroid_new_track_total_time=}")

 4459:                     #self.explanation_messages.append(f"In this scenario, I have simulated {float(total_sim_timesteps)*DELTA_TIME/60:0.0f} minutes of gameplay!")

 4460:                     #self.explanation_messages.append(f"We simulated {total_bullet_sim_timesteps} bullet sim timesteps and {total_bullet_sim_iterations} iterations, and {total_sim_timesteps} timesteps, and {update_ts_multiple_count=} {update_ts_zero_count=}")

+4461:                     turn_direction = 0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __pyx_v_turn_direction = __pyx_mstate_global->__pyx_int_0;

+4462:                     idle_thrust = 0.0

        __pyx_v_idle_thrust = 0.0;
      }
      __pyx_L74:;

 4463:                 # We still simulate one iteration of this, because if we had a pending shot from before, this will do the shot!

+4464:                 sim_complete_without_crash = self.update(idle_thrust, SHIP_MAX_TURN_RATE*turn_direction, False, False)

      __pyx_t_9 = __pyx_cur_scope->__pyx_v_self;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_23 = PyFloat_FromDouble(__pyx_v_idle_thrust); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4464, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4464, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_3 = PyNumber_Multiply(__pyx_t_22, __pyx_v_turn_direction); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4464, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[5] = {__pyx_t_9, __pyx_t_23, __pyx_t_3, Py_False, Py_False};
        __pyx_t_25 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4464, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
      }
      __pyx_v_sim_complete_without_crash = __pyx_t_25;
      __pyx_t_25 = 0;

+4465:                 assert is_close_to_zero(self.ship_state.speed), f"When returning in target selection where the return value of whether we didn't crash is {sim_complete_without_crash}, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}"  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_3 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4465, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4465, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4465, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_23))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_23);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_22};
          __pyx_t_25 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
        }
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4465, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        if (unlikely(!__pyx_t_17)) {
          __pyx_t_25 = __Pyx_PyObject_FormatSimple(__pyx_v_sim_complete_without_crash, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __pyx_t_23 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_22), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __pyx_t_22 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_3), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_30[0] = __pyx_mstate_global->__pyx_kp_u_When_returning_in_target_selecti;
          __pyx_t_30[1] = __pyx_t_25;
          __pyx_t_30[2] = __pyx_mstate_global->__pyx_kp_u_the_ship_speed_is_not_zero_self;
          __pyx_t_30[3] = __pyx_t_23;
          __pyx_t_30[4] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_velocity_2;
          __pyx_t_30[5] = __pyx_t_22;
          __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_30, 6, 88 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25) + 52 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_23) + 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_22), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_23) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_22));
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4465, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_3, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4465, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 4465, __pyx_L1_error)
      #endif

+4466:                 return sim_complete_without_crash

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_v_sim_complete_without_crash);
      __pyx_r = __pyx_v_sim_complete_without_crash;
      goto __pyx_L0;
    }
    __pyx_L65:;

 4467: 

 4468:         # debug_print('Closest ang asteroid:')

 4469:         # debug_print(target_asteroids_list[least_angular_distance_asteroid_index])

 4470:         # debug_print('Second closest ang asteroid:')

 4471:         # debug_print(target_asteroids_list[second_least_angular_distance_asteroid_index])

 4472: 

 4473:         # print(f"Bullet should have been fired on simulated timestep {self.initial_timestep + self.future_timesteps + len(aiming_move_sequence)}")

 4474: 

 4475:         # The following code is confusing, because we're working with different times.

 4476:         # We need to make sure that when we talk about an asteroid, we talk about its position at a specific time. If the time we talk about is not synced up with the position, everything's wrong.

 4477:         # So if an asteroid is on position 1 at time 1, position 2 at time 2, position 3 at time 3, etc, then we must associate the asteroid with a timestep.

 4478:         # A smarter, less buggy way to store asteroids is to include not only their position, but their timestep as well. But too late.

 4479:         # Timestep [self.initial_timestep + self.future_timesteps] is the current timestep, or the timestep the sim was started on. Future timesteps should be 0 so far since we haven't moved.

 4480:         # Timestep [self.initial_timestep + self.future_timesteps + len(aiming_move_sequence)] gives us the timestep after we do our aiming, and when we shoot our bullet

 4481:         # Timestep [self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid] gives us the timestep the asteroid got hit

 4482: 

+4483:         if actual_asteroid_hit is not None:

  __pyx_t_17 = (__pyx_v_actual_asteroid_hit != Py_None);
  if (__pyx_t_17) {
/* … */
  }

+4484:             assert timesteps_until_bullet_hit_asteroid is not None

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4484, __pyx_L1_error) }
      __pyx_t_17 = (__pyx_v_timesteps_until_bullet_hit_asteroid != Py_None);
      if (unlikely(!__pyx_t_17)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4484, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4484, __pyx_L1_error)
    #endif

+4485:             actual_asteroid_hit_when_firing = time_travel_asteroid(actual_asteroid_hit, len(aiming_move_sequence) - timesteps_until_bullet_hit_asteroid, self.game_state)

    __pyx_t_22 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4485, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
      __PYX_ERR(0, 4485, __pyx_L1_error)
    }
    __pyx_t_13 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4485, __pyx_L1_error)
    __pyx_t_25 = PyLong_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4485, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4485, __pyx_L1_error) }
    __pyx_t_9 = PyNumber_Subtract(__pyx_t_25, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4485, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4485, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_23))) {
      __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_23);
      assert(__pyx_t_22);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
      __Pyx_INCREF(__pyx_t_22);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_22, __pyx_v_actual_asteroid_hit, __pyx_t_9, __pyx_t_25};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4485, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_XDECREF_SET(__pyx_v_actual_asteroid_hit_when_firing, __pyx_t_3);
    __pyx_t_3 = 0;

+4486:             if not isinf(self.game_state.time_limit) and self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid > floor(FPS*self.game_state.time_limit):

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_28 = __Pyx_PyFloat_AsDouble(__pyx_t_23); if (unlikely((__pyx_t_28 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_11 = (!(isinf(__pyx_t_28) != 0));
    if (__pyx_t_11) {
    } else {
      __pyx_t_17 = __pyx_t_11;
      goto __pyx_L78_bool_binop_done;
    }
    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_25 = PyNumber_Add(__pyx_t_23, __pyx_t_3); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4486, __pyx_L1_error) }
    __pyx_t_3 = PyNumber_Add(__pyx_t_25, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_23 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_22);
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_19 = PyNumber_Multiply(__pyx_t_22, __pyx_t_7); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_23);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_23);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_23, __pyx_t_19};
      __pyx_t_25 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4486, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
    }
    __pyx_t_9 = PyObject_RichCompare(__pyx_t_3, __pyx_t_25, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4486, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_17 = __pyx_t_11;
    __pyx_L78_bool_binop_done:;
    if (__pyx_t_17) {
/* … */
    }

 4487:                 # Added one to the timesteps to prevent off by one :P

 4488:                 #print('WITHHOLDING SHOT IN TARGET SELECTION BECAUSE SCENARIO IS ENDING')

+4489:                 self.fire_next_timestep_flag = False

      if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 4489, __pyx_L1_error)

+4490:                 sim_complete_without_crash = self.update(0.0, 0.0, False, False)

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_update); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_25 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_mstate_global->__pyx_tuple[26], NULL); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_v_sim_complete_without_crash = __pyx_t_25;
      __pyx_t_25 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[26] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_float_0_0, __pyx_mstate_global->__pyx_float_0_0, Py_False, Py_False); if (unlikely(!__pyx_mstate_global->__pyx_tuple[26])) __PYX_ERR(0, 4490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[26]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[26]);

+4491:                 return sim_complete_without_crash

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(__pyx_v_sim_complete_without_crash);
      __pyx_r = __pyx_v_sim_complete_without_crash;
      goto __pyx_L0;

 4492:         # TODO: This following statement, doesn't this mean if I accidentally hit something in the way that I already shot, then I just won't even try to shoot at all? Even though the bullet should still hit what's behind it some of the time at least?

 4493:         # TODO: Or maybe this case isn't even possible because I do the sim to make sure that I hit whatever I wanted to hit, and if I had a pending shot, that shot would have hit it so this would never happen!

+4494:         if actual_asteroid_hit is None or not check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len(aiming_move_sequence), self.game_state, actual_asteroid_hit_when_firing):

  __pyx_t_11 = (__pyx_v_actual_asteroid_hit == Py_None);
  if (!__pyx_t_11) {
  } else {
    __pyx_t_17 = __pyx_t_11;
    goto __pyx_L81_bool_binop_done;
  }
  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_19);
  __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_22 = PyNumber_Add(__pyx_t_23, __pyx_t_7); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 4494, __pyx_L1_error)
  }
  __pyx_t_13 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4494, __pyx_L1_error)
  __pyx_t_7 = PyLong_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_23 = PyNumber_Add(__pyx_t_22, __pyx_t_7); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (unlikely(!__pyx_v_actual_asteroid_hit_when_firing)) { __Pyx_RaiseUnboundLocalError("actual_asteroid_hit_when_firing"); __PYX_ERR(0, 4494, __pyx_L1_error) }
  __pyx_t_10 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_10 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[5] = {__pyx_t_9, __pyx_t_19, __pyx_t_23, __pyx_t_7, __pyx_v_actual_asteroid_hit_when_firing};
    __pyx_t_25 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4494, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
  }
  __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4494, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
  __pyx_t_31 = (!__pyx_t_11);
  __pyx_t_17 = __pyx_t_31;
  __pyx_L81_bool_binop_done:;
  if (__pyx_t_17) {
/* … */
  }

 4495:             # We can't seem to hit anything on this timestep. Maybe the asteroids are done being shot, or maybe we can't hit them because of the way things are lined up and the bullets skip over the asteroids, idk.

 4496:             # if ENABLE_ASSERTIONS and actual_asteroid_hit is not None:

 4497:             # TODO: This is testing above theory to see if it holds

 4498:             #    assert check_whether_this_is_a_new_asteroid_we_do_not_have_a_pending_shot_for(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len(aiming_move_sequence), self.game_state, actual_asteroid_hit_when_firing), f"WTH this asteroid: {actual_asteroid_hit_when_firing}, whole freaking dict: {self.asteroids_pending_death}"

+4499:             self.fire_next_timestep_flag = False

    if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 4499, __pyx_L1_error)

 4500:             # print("We can't hit anything this timestep.")

+4501:             if asteroids_still_exist:

    if (__pyx_v_asteroids_still_exist) {
/* … */
      goto __pyx_L83;
    }

 4502:                 # print('asteroids still exist')

+4503:                 if random.randint(1, 10) == 1:

      __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4503, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_randint); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4503, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[25], NULL); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4503, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_17 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_25, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4503, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      if (__pyx_t_17) {
/* … */
      }

+4504:                     self.explanation_messages.append("Asteroids exist but we can't hit them. Moving around a bit randomly.")

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4504, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_25, __pyx_mstate_global->__pyx_kp_u_Asteroids_exist_but_we_can_t_hit); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(0, 4504, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;

 4505:                     # Setting this to -1 is a signal to set the asteroid fitness really low, so hopefully we'll choose actions that'll move around

+4506:                     self.asteroids_shot -= 1

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4506, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_3 = __Pyx_PyLong_SubtractObjC(__pyx_t_25, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4506, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_t_3) < 0) __PYX_ERR(0, 4506, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 4507:                 # turn_direction = random.random()

 4508:                 # idle_thrust = random.triangular(0, SHIP_MAX_THRUST, 0)

+4509:                 turn_direction = 0

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_v_turn_direction = __pyx_mstate_global->__pyx_int_0;

+4510:                 idle_thrust = 0.0

      __pyx_v_idle_thrust = 0.0;

 4511:             else:

 4512:                 # print('asteroids DO NOT exist')

+4513:                 turn_direction = 0

    /*else*/ {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_v_turn_direction = __pyx_mstate_global->__pyx_int_0;

+4514:                 idle_thrust = 0.0

      __pyx_v_idle_thrust = 0.0;
    }
    __pyx_L83:;

 4515:             # print(f"Calling update from targ sel:")

+4516:             sim_complete_without_crash = self.update(idle_thrust, SHIP_MAX_TURN_RATE*turn_direction, False, False)

    __pyx_t_25 = __pyx_cur_scope->__pyx_v_self;
    __Pyx_INCREF(__pyx_t_25);
    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_idle_thrust); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4516, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4516, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_19 = PyNumber_Multiply(__pyx_t_23, __pyx_v_turn_direction); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4516, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_10 = 0;
    {
      PyObject *__pyx_callargs[5] = {__pyx_t_25, __pyx_t_7, __pyx_t_19, Py_False, Py_False};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4516, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_v_sim_complete_without_crash = __pyx_t_3;
    __pyx_t_3 = 0;

 4517:             # print(f"Sim id {self.sim_id} is returning from target sim with success value {sim_complete_without_crash}")

+4518:             assert is_close_to_zero(self.ship_state.speed), f"When returning in target sel where the return value of whether we didn't crash is {sim_complete_without_crash}, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}"  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_19 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4518, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4518, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4518, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_19);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_19);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_19, __pyx_t_23};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4518, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_17)) {
        __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_sim_complete_without_crash, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_7 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_23), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_19), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __pyx_t_30[0] = __pyx_mstate_global->__pyx_kp_u_When_returning_in_target_sel_whe;
        __pyx_t_30[1] = __pyx_t_3;
        __pyx_t_30[2] = __pyx_mstate_global->__pyx_kp_u_the_ship_speed_is_not_zero_self;
        __pyx_t_30[3] = __pyx_t_7;
        __pyx_t_30[4] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_velocity_2;
        __pyx_t_30[5] = __pyx_t_23;
        __pyx_t_19 = __Pyx_PyUnicode_Join(__pyx_t_30, 6, 82 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 52 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_23), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_23));
        if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4518, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_19, 0, 0);
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __PYX_ERR(0, 4518, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4518, __pyx_L1_error)
    #endif

+4519:             return sim_complete_without_crash

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_sim_complete_without_crash);
    __pyx_r = __pyx_v_sim_complete_without_crash;
    goto __pyx_L0;

 4520:         else:

 4521:             # We're able to hit an asteroid! We're committing to it.

+4522:             assert timesteps_until_bullet_hit_asteroid is not None

  /*else*/ {
    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4522, __pyx_L1_error) }
      __pyx_t_17 = (__pyx_v_timesteps_until_bullet_hit_asteroid != Py_None);
      if (unlikely(!__pyx_t_17)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4522, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4522, __pyx_L1_error)
    #endif

 4523:             # print(f"Asserting that we don't have a pending shot for asteroid {ast_to_string(actual_asteroid_hit)} on timestep {self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid}")

+4524:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4524, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4524, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_17) {
/* … */
    }

+4525:                 assert check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid, self.game_state, actual_asteroid_hit)  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_23 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_22 = PyNumber_Add(__pyx_t_25, __pyx_t_9); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4525, __pyx_L1_error) }
        __pyx_t_9 = PyNumber_Add(__pyx_t_22, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_7))) {
          __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_7);
          assert(__pyx_t_23);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
          __Pyx_INCREF(__pyx_t_23);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_23, __pyx_t_3, __pyx_t_9, __pyx_t_22, __pyx_v_actual_asteroid_hit};
          __pyx_t_19 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4525, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
        }
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4525, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_17)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 4525, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 4525, __pyx_L1_error)
      #endif

 4526:             # print(f"Current timestep: {self.initial_timestep + self.future_timesteps}, and the aiming maneuver is {len(aiming_move_sequence)}")

 4527:             # print(self.asteroids_pending_death)

 4528:             # actual_asteroid_hit_when_firing = time_travel_asteroid(actual_asteroid_hit, len(aiming_move_sequence) - timesteps_until_bullet_hit_asteroid, self.game_state)

 4529:             # print(f"Asserting that we don't have a pending shot for asteroid {ast_to_string(actual_asteroid_hit_when_firing)} on timestep {self.initial_timestep + self.future_timesteps + len(aiming_move_sequence)}")

+4530:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4530, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4530, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_17) {
/* … */
    }

+4531:                 assert check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len(aiming_move_sequence), self.game_state, actual_asteroid_hit_when_firing)  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_7 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_25 = PyNumber_Add(__pyx_t_3, __pyx_t_23); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
          __PYX_ERR(0, 4531, __pyx_L1_error)
        }
        __pyx_t_13 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4531, __pyx_L1_error)
        __pyx_t_23 = PyLong_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_3 = PyNumber_Add(__pyx_t_25, __pyx_t_23); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        if (unlikely(!__pyx_v_actual_asteroid_hit_when_firing)) { __Pyx_RaiseUnboundLocalError("actual_asteroid_hit_when_firing"); __PYX_ERR(0, 4531, __pyx_L1_error) }
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_22))) {
          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_22);
          assert(__pyx_t_7);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_22);
          __Pyx_INCREF(__pyx_t_7);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_22, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_7, __pyx_t_9, __pyx_t_3, __pyx_t_23, __pyx_v_actual_asteroid_hit_when_firing};
          __pyx_t_19 = __Pyx_PyObject_FastCall(__pyx_t_22, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4531, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
        }
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4531, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_17)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 4531, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 4531, __pyx_L1_error)
      #endif

 4532:                 # assert check_whether_this_is_a_new_asteroid_we_do_not_have_a_pending_shot_for(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + len(aiming_move_sequence) - 1, self.game_state, actual_asteroid_hit_when_firing)

 4533: 

 4534:             # actual_asteroid_hit_UNEXTRAPOLATED = dict(actual_asteroid_hit)

 4535:             # This back-extrapolates the asteroid to when we're firing our bullet

 4536: 

 4537:             #debug_print(f"We used a sim to forecast the asteroid that we'll hit being the one at pos ({actual_asteroid_hit.position[0]}, {actual_asteroid_hit.position[1]}) with vel ({actual_asteroid_hit.velocity[0]}, {actual_asteroid_hit.velocity[1]}) in {timesteps_until_bullet_hit_asteroid - len(aiming_move_sequence)} timesteps")

 4538:             #debug_print(f"The primitive forecast would have said we'd hit asteroid at pos ({target_asteroid.position[0]}, {target_asteroid.position[1]}) with vel ({target_asteroid.velocity[0]}, {target_asteroid.velocity[1]}) in {calculate_timesteps_until_bullet_hits_asteroid(target_asteroid_interception_time_s, target_asteroid.radius)} timesteps")

 4539:             # print(self.asteroids_pending_death)

 4540:             # print(f"\nTracking that we just shot at the asteroid {ast_to_string(actual_asteroid_hit)}, our intended target was {target_asteroid}")

 4541:             # actual_asteroid_hit_UNEXTRAPOLATED = extrapolate_asteroid_forward(actual_asteroid_hit, -(len(aiming_move_sequence) - timesteps_until_bullet_hit_asteroid), self.game_state, True)

+4542:             actual_asteroid_hit_at_present_time = time_travel_asteroid(actual_asteroid_hit, -timesteps_until_bullet_hit_asteroid, self.game_state)

    __pyx_t_22 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4542, __pyx_L1_error) }
    __pyx_t_3 = PyNumber_Negative(__pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_23))) {
      __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_23);
      assert(__pyx_t_22);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
      __Pyx_INCREF(__pyx_t_22);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_22, __pyx_v_actual_asteroid_hit, __pyx_t_3, __pyx_t_9};
      __pyx_t_19 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
    }
    __pyx_v_actual_asteroid_hit_at_present_time = __pyx_t_19;
    __pyx_t_19 = 0;

+4543:             if self.game_state_plotter is not None and GAMESTATE_PLOTTING and NEXT_TARGET_PLOTTING and (START_GAMESTATE_PLOTTING_AT_SECOND is None or START_GAMESTATE_PLOTTING_AT_SECOND*FPS <= float(self.initial_timestep + self.future_timesteps)):  # REMOVE_FOR_COMPETITION

    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_31 = (__pyx_t_19 != Py_None);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_31) {
    } else {
      __pyx_t_17 = __pyx_t_31;
      goto __pyx_L88_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_GAMESTATE_PLOTTING); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_31 < 0))) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_31) {
    } else {
      __pyx_t_17 = __pyx_t_31;
      goto __pyx_L88_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_NEXT_TARGET_PLOTTING); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_31 < 0))) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_31) {
    } else {
      __pyx_t_17 = __pyx_t_31;
      goto __pyx_L88_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_31 = (__pyx_t_19 == Py_None);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (!__pyx_t_31) {
    } else {
      __pyx_t_17 = __pyx_t_31;
      goto __pyx_L88_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_9 = PyNumber_Multiply(__pyx_t_19, __pyx_t_23); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_3 = PyNumber_Add(__pyx_t_23, __pyx_t_19); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_19 = __Pyx_PyNumber_Float(__pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_9, __pyx_t_19, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_31 < 0))) __PYX_ERR(0, 4543, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_17 = __pyx_t_31;
    __pyx_L88_bool_binop_done:;
    if (__pyx_t_17) {
/* … */
    }

+4544:                 actual_asteroid_hit_at_present_time_for_plotting = time_travel_asteroid(actual_asteroid_hit, -timesteps_until_bullet_hit_asteroid - 1, self.game_state)  # REMOVE_FOR_COMPETITION

      __pyx_t_19 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4544, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4544, __pyx_L1_error) }
      __pyx_t_23 = PyNumber_Negative(__pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4544, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_22 = __Pyx_PyLong_SubtractObjC(__pyx_t_23, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4544, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4544, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_19);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_19);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_19, __pyx_v_actual_asteroid_hit, __pyx_t_22, __pyx_t_23};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4544, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_v_actual_asteroid_hit_at_present_time_for_plotting = __pyx_t_3;
      __pyx_t_3 = 0;

+4545:                 self.game_state_plotter.update_plot(None, None, None, None, [actual_asteroid_hit_at_present_time_for_plotting], None, None, None, False, NEW_TARGET_PLOT_PAUSE_TIME_S, 'FEASIBLE TARGETS')  # [dict(a.asteroid) for a in sorted_targets]  # REMOVE_FOR_COMPETITION

      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_9 = __pyx_t_23;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_22 = PyList_New(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_INCREF(__pyx_v_actual_asteroid_hit_at_present_time_for_plotting);
      __Pyx_GIVEREF(__pyx_v_actual_asteroid_hit_at_present_time_for_plotting);
      if (__Pyx_PyList_SET_ITEM(__pyx_t_22, 0, __pyx_v_actual_asteroid_hit_at_present_time_for_plotting) != (0)) __PYX_ERR(0, 4545, __pyx_L1_error);
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_NEW_TARGET_PLOT_PAUSE_TIME_S); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[12] = {__pyx_t_9, Py_None, Py_None, Py_None, Py_None, __pyx_t_22, Py_None, Py_None, Py_None, Py_False, __pyx_t_19, __pyx_mstate_global->__pyx_kp_u_FEASIBLE_TARGETS};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update_plot, __pyx_callargs+__pyx_t_10, (12-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4545, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 4546:             # actual_asteroid_hit_tracking_purposes_super_early = extrapolate_asteroid_forward(actual_asteroid_hit, )

 4547:             # print(f"Asserting that we don't have a pending shot for asteroid {ast_to_string(actual_asteroid_hit_at_present_time)} on timestep {self.initial_timestep + self.future_timesteps}")

 4548:             # assert check_whether_this_is_a_new_asteroid_we_do_not_have_a_pending_shot_for(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + 0*len(aiming_move_sequence), self.game_state, actual_asteroid_hit_at_present_time)

 4549:             # print(f'\n\nTracking that we shot at the asteroid {ast_to_string(actual_asteroid_hit_at_present_time)} at the timestep after turning {self.initial_timestep + self.future_timesteps + len(aiming_move_sequence) - 1}')

 4550:             # print(self.asteroids_pending_death)

 4551:             # debug_print(f"Move seq is len {len(aiming_move_sequence)} and is {aiming_move_sequence}")

 4552:             # debug_print(f"We're in the future by {self.future_timesteps} timesteps")

 4553:             # actual_asteroid_hit_when_firing['trace'] = f"Asteroid added from target selection sim id {self.sim_id}, self.initial_timestep {self.initial_timestep} self.future_timesteps {self.future_timesteps} aiming_move_sequence {aiming_move_sequence}"

 4554: 

 4555:             # debug_print('Were gonna fire the next timestep! Printing out the move sequence:', aiming_move_sequence)

 4556:             # TODO: Currently Neo can't fire on timestep 1! Fix this! Although it's only a minor issue.

+4557:             future_ts_backup = self.future_timesteps

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4557, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_v_future_ts_backup = __pyx_t_3;
    __pyx_t_3 = 0;

 4558:             # Forecasted splits get progressed while doing the move sequence which includes rotation, so we need to start the forecast before the rotation even starts

+4559:             if actual_asteroid_hit_at_present_time.size != 1:

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_actual_asteroid_hit_at_present_time, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4559, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_17 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4559, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_17) {
/* … */
    }

 4560:                 #print("Calling forecast ast bull splits from targ sel")

+4561:                 self.forecasted_asteroid_splits.extend(forecast_asteroid_bullet_splits_from_heading(actual_asteroid_hit_at_present_time, timesteps_until_bullet_hit_asteroid, ship_state_after_aiming.heading, self.game_state))

      __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_23 = __pyx_t_19;
      __Pyx_INCREF(__pyx_t_23);
      __pyx_t_9 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_bullet_splits); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4561, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_state_after_aiming)) { __Pyx_RaiseUnboundLocalError("ship_state_after_aiming"); __PYX_ERR(0, 4561, __pyx_L1_error) }
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state_after_aiming, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_9);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_9);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[5] = {__pyx_t_9, __pyx_v_actual_asteroid_hit_at_present_time, __pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_25, __pyx_t_6};
        __pyx_t_22 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (5-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4561, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
      }
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_23, __pyx_t_22};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4561, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 4562:                 # print(f"In targeting, Forecasted asteroid splits on ts {self.initial_timestep + self.future_timesteps} is {self.forecasted_asteroid_splits}")

+4563:             sim_complete_without_crash = self.apply_move_sequence(aiming_move_sequence)

    __pyx_t_19 = __pyx_cur_scope->__pyx_v_self;
    __Pyx_INCREF(__pyx_t_19);
    __pyx_t_10 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_19, __pyx_v_aiming_move_sequence};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_apply_move_sequence, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4563, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_v_sim_complete_without_crash = __pyx_t_3;
    __pyx_t_3 = 0;

+4564:             if sim_complete_without_crash:

    __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_sim_complete_without_crash); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4564, __pyx_L1_error)
    if (__pyx_t_17) {
/* … */
      goto __pyx_L94;
    }

 4565:                 # We only do, and track the shot if the sim completed without death

+4566:                 self.asteroids_shot += 1

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4566, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_19 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4566, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_t_19) < 0) __PYX_ERR(0, 4566, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

+4567:                 self.fire_next_timestep_flag = True

      if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_True) < 0) __PYX_ERR(0, 4567, __pyx_L1_error)

+4568:                 assert future_ts_backup + len(aiming_move_sequence) == self.future_timesteps  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
          __PYX_ERR(0, 4568, __pyx_L1_error)
        }
        __pyx_t_13 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4568, __pyx_L1_error)
        __pyx_t_19 = PyLong_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4568, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __pyx_t_3 = PyNumber_Add(__pyx_v_future_ts_backup, __pyx_t_19); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4568, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4568, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __pyx_t_22 = PyObject_RichCompare(__pyx_t_3, __pyx_t_19, Py_EQ); __Pyx_XGOTREF(__pyx_t_22); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4568, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4568, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        if (unlikely(!__pyx_t_17)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 4568, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 4568, __pyx_L1_error)
      #endif

 4569:                 #if is_close(-10.0, actual_asteroid_hit_when_firing.velocity[0]):

 4570:                 #    print(f"\nSHOT AT THE ASTEROID IN TARGET SELECTION on timestep {self.initial_timestep=} {self.future_timesteps=}")

+4571:                 track_asteroid_we_shot_at(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps, self.game_state, timesteps_until_bullet_hit_asteroid - len(aiming_move_sequence), actual_asteroid_hit_when_firing)

      __pyx_t_19 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_track_asteroid_we_shot_at); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_25 = PyNumber_Add(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      if (unlikely(!__pyx_v_timesteps_until_bullet_hit_asteroid)) { __Pyx_RaiseUnboundLocalError("timesteps_until_bullet_hit_asteroid"); __PYX_ERR(0, 4571, __pyx_L1_error) }
      if (unlikely(__pyx_v_aiming_move_sequence == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
        __PYX_ERR(0, 4571, __pyx_L1_error)
      }
      __pyx_t_13 = __Pyx_PyList_GET_SIZE(__pyx_v_aiming_move_sequence); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4571, __pyx_L1_error)
      __pyx_t_7 = PyLong_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_9 = PyNumber_Subtract(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4571, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_v_actual_asteroid_hit_when_firing)) { __Pyx_RaiseUnboundLocalError("actual_asteroid_hit_when_firing"); __PYX_ERR(0, 4571, __pyx_L1_error) }
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_19);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_19);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[6] = {__pyx_t_19, __pyx_t_23, __pyx_t_25, __pyx_t_6, __pyx_t_9, __pyx_v_actual_asteroid_hit_when_firing};
        __pyx_t_22 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_10, (6-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4571, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
      }
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;

 4572:                 # print(f"self.asteroids_pending_death updated to {self.asteroids_pending_death[100]}")

 4573:                 # print(self.asteroids_pending_death)

 4574:             else:

 4575:                 # If we died, we're gonna do a respawn maneuver and we won't shoot because that will remove our 3 second respawn invincibility immediately

+4576:                 self.fire_next_timestep_flag = False

    /*else*/ {
      if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 4576, __pyx_L1_error)
    }
    __pyx_L94:;

 4577:             # print('THE ACTUAL MOVE SEQUENCE WE GET BACK FROM THE SIM:')

 4578:             # print(self.ship_move_sequence)

 4579:             # debug_print(f"Sim id {self.sim_id} is returning from target sim with success value {sim_complete_without_crash}")

+4580:             assert is_close_to_zero(self.ship_state.speed), f"When returning in target selection's end where the return value is {sim_complete_without_crash}, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}"  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4580, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4580, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4580, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_25};
        __pyx_t_22 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
      }
      __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 4580, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      if (unlikely(!__pyx_t_17)) {
        __pyx_t_22 = __Pyx_PyObject_FormatSimple(__pyx_v_sim_complete_without_crash, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_25), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_t_25 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_3), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_30[0] = __pyx_mstate_global->__pyx_kp_u_When_returning_in_target_selecti_2;
        __pyx_t_30[1] = __pyx_t_22;
        __pyx_t_30[2] = __pyx_mstate_global->__pyx_kp_u_the_ship_speed_is_not_zero_self;
        __pyx_t_30[3] = __pyx_t_9;
        __pyx_t_30[4] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_velocity_2;
        __pyx_t_30[5] = __pyx_t_25;
        __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_30, 6, 67 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_22) + 52 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_22) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25));
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_3, 0, 0);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __PYX_ERR(0, 4580, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4580, __pyx_L1_error)
    #endif

+4581:             return sim_complete_without_crash

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_sim_complete_without_crash);
    __pyx_r = __pyx_v_sim_complete_without_crash;
    goto __pyx_L0;
  }

 4582: 

+4583:     def bullet_sim(self, ship_state: Optional[Ship] = None, fire_first_timestep: bool = False, fire_after_timesteps: int = 0, skip_half_of_first_cycle: bool = False, current_move_index: Optional[int] = None, whole_move_sequence: Optional[list[Action]] = None, timestep_limit: int = INT_INF, asteroids_to_check: Optional[list[Asteroid]] = None) -> tuple[Optional[Asteroid], int, bool]:

static PyObject *__pyx_pf_14neo_controller_161__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, Py_None) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_False));
  __Pyx_GIVEREF(((PyObject*)Py_False));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_int_0));
  __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_int_0));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject*)__pyx_mstate_global->__pyx_int_0)) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(((PyObject*)Py_False));
  __Pyx_GIVEREF(((PyObject*)Py_False));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, Py_None) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 5, Py_None) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 7, Py_None) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 4583, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_49bullet_sim(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_49bullet_sim = {"bullet_sim", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_49bullet_sim, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_49bullet_sim(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  PyObject *__pyx_v_fire_first_timestep = 0;
  PyObject *__pyx_v_fire_after_timesteps = 0;
  PyObject *__pyx_v_skip_half_of_first_cycle = 0;
  PyObject *__pyx_v_current_move_index = 0;
  PyObject *__pyx_v_whole_move_sequence = 0;
  PyObject *__pyx_v_timestep_limit = 0;
  PyObject *__pyx_v_asteroids_to_check = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("bullet_sim (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_fire_first_timestep,&__pyx_mstate_global->__pyx_n_u_fire_after_timesteps,&__pyx_mstate_global->__pyx_n_u_skip_half_of_first_cycle,&__pyx_mstate_global->__pyx_n_u_current_move_index,&__pyx_mstate_global->__pyx_n_u_whole_move_sequence,&__pyx_mstate_global->__pyx_n_u_timestep_limit,&__pyx_mstate_global->__pyx_n_u_asteroids_to_check,0};
  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};
    struct __pyx_defaults1 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self);
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4583, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bullet_sim", 0) < 0) __PYX_ERR(0, 4583, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_14neo_controller_Ship *)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[7]) values[7] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[8]) values[8] = __Pyx_NewRef(((PyObject*)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bullet_sim", 0, 1, 9, i); __PYX_ERR(0, 4583, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  9:
        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  8:
        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4583, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4583, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_14neo_controller_Ship *)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject*)((PyObject*)__pyx_mstate_global->__pyx_int_0)));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[7]) values[7] = __Pyx_NewRef(__pyx_dynamic_args->arg0);
      if (!values[8]) values[8] = __Pyx_NewRef(((PyObject*)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[1]);
    __pyx_v_fire_first_timestep = values[2];
    __pyx_v_fire_after_timesteps = ((PyObject*)values[3]);
    __pyx_v_skip_half_of_first_cycle = values[4];
    __pyx_v_current_move_index = ((PyObject*)values[5]);
    __pyx_v_whole_move_sequence = ((PyObject*)values[6]);
    __pyx_v_timestep_limit = ((PyObject*)values[7]);
    __pyx_v_asteroids_to_check = ((PyObject*)values[8]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("bullet_sim", 0, 1, 9, __pyx_nargs); __PYX_ERR(0, 4583, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.bullet_sim", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 1, "ship_state", 0))) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_fire_after_timesteps), (&PyLong_Type), 0, "fire_after_timesteps", 2))) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_current_move_index), (&PyLong_Type), 1, "current_move_index", 2))) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_whole_move_sequence), (&PyList_Type), 1, "whole_move_sequence", 2))) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timestep_limit), (&PyLong_Type), 0, "timestep_limit", 2))) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_asteroids_to_check), (&PyList_Type), 1, "asteroids_to_check", 2))) __PYX_ERR(0, 4583, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_48bullet_sim(__pyx_self, __pyx_v_self, __pyx_v_ship_state, __pyx_v_fire_first_timestep, __pyx_v_fire_after_timesteps, __pyx_v_skip_half_of_first_cycle, __pyx_v_current_move_index, __pyx_v_whole_move_sequence, __pyx_v_timestep_limit, __pyx_v_asteroids_to_check);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_48bullet_sim(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state, PyObject *__pyx_v_fire_first_timestep, PyObject *__pyx_v_fire_after_timesteps, PyObject *__pyx_v_skip_half_of_first_cycle, PyObject *__pyx_v_current_move_index, PyObject *__pyx_v_whole_move_sequence, PyObject *__pyx_v_timestep_limit, PyObject *__pyx_v_asteroids_to_check) {
  PyObject *__pyx_v_asteroids = NULL;
  PyObject *__pyx_v_mines = 0;
  PyObject *__pyx_v_bullets = 0;
  PyObject *__pyx_v_initial_ship_state = NULL;
  PyObject *__pyx_v_bullet_sim_ship_state = NULL;
  struct __pyx_obj_14neo_controller_Bullet *__pyx_v_my_bullet = 0;
  int __pyx_v_ship_not_collided_with_asteroid;
  PyObject *__pyx_v_timesteps_until_bullet_hit_asteroid = 0;
  PyObject *__pyx_v_asteroid_remove_idxs = 0;
  PyObject *__pyx_v_flattened_asteroids_pending_death = NULL;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_plot_state = 0;
  PyObject *__pyx_v_bullet_remove_idxs = 0;
  Py_ssize_t __pyx_v_b_ind;
  PyObject *__pyx_v_b = NULL;
  PyObject *__pyx_v_new_bullet_pos = NULL;
  PyObject *__pyx_v_my_new_bullet_pos = NULL;
  PyObject *__pyx_v_m = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_rad_heading = NULL;
  double __pyx_v_cos_heading;
  double __pyx_v_sin_heading;
  PyObject *__pyx_v_bullet_x = NULL;
  PyObject *__pyx_v_bullet_y = NULL;
  PyObject *__pyx_v_vx = NULL;
  PyObject *__pyx_v_vy = NULL;
  struct __pyx_obj_14neo_controller_Bullet *__pyx_v_initial_timestep_fire_bullet = NULL;
  PyObject *__pyx_v_bullet_fired_from_ship_heading = NULL;
  PyObject *__pyx_v_bullet_fired_from_ship_position = NULL;
  PyObject *__pyx_v_thrust = NULL;
  PyObject *__pyx_v_turn_rate = NULL;
  PyObject *__pyx_v_drag_amount = NULL;
  Py_ssize_t __pyx_v_len_bullets;
  PyObject *__pyx_v_b_idx = NULL;
  PyObject *__pyx_v_b_tail = NULL;
  PyObject *__pyx_v_a_idx = NULL;
  PyObject *__pyx_v_mine_remove_idxs = 0;
  PyObject *__pyx_v_new_asteroids = 0;
  Py_ssize_t __pyx_v_m_idx;
  PyObject *__pyx_v_mine = NULL;
  PyObject *__pyx_v_asteroid = NULL;
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  PyObject *__pyx_v_separation = NULL;
  PyObject *__pyx_v_ship_position = NULL;
  PyObject *__pyx_9genexpr36__pyx_v_a = NULL;
  PyObject *__pyx_9genexpr37__pyx_v_a = NULL;
  PyObject *__pyx_9genexpr38__pyx_v_m = NULL;
  PyObject *__pyx_9genexpr39__pyx_v_b = NULL;
  PyObject *__pyx_9genexpr40__pyx_v_ast_list = NULL;
  PyObject *__pyx_9genexpr40__pyx_v_ast = NULL;
  Py_ssize_t __pyx_9genexpr41__pyx_v_idx;
  PyObject *__pyx_9genexpr41__pyx_v_bullet = NULL;
  Py_ssize_t __pyx_9genexpr42__pyx_v_idx;
  PyObject *__pyx_9genexpr42__pyx_v_bullet = NULL;
  Py_ssize_t __pyx_9genexpr43__pyx_v_idx;
  PyObject *__pyx_9genexpr43__pyx_v_mine = NULL;
  PyObject *__pyx_9genexpr44__pyx_v_idx = NULL;
  PyObject *__pyx_9genexpr44__pyx_v_asteroid = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_AddTraceback("neo_controller.Matrix.bullet_sim", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_asteroids);
  __Pyx_XDECREF(__pyx_v_mines);
  __Pyx_XDECREF(__pyx_v_bullets);
  __Pyx_XDECREF(__pyx_v_initial_ship_state);
  __Pyx_XDECREF(__pyx_v_bullet_sim_ship_state);
  __Pyx_XDECREF((PyObject *)__pyx_v_my_bullet);
  __Pyx_XDECREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
  __Pyx_XDECREF(__pyx_v_asteroid_remove_idxs);
  __Pyx_XDECREF(__pyx_v_flattened_asteroids_pending_death);
  __Pyx_XDECREF((PyObject *)__pyx_v_ship_plot_state);
  __Pyx_XDECREF(__pyx_v_bullet_remove_idxs);
  __Pyx_XDECREF(__pyx_v_b);
  __Pyx_XDECREF(__pyx_v_new_bullet_pos);
  __Pyx_XDECREF(__pyx_v_my_new_bullet_pos);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_rad_heading);
  __Pyx_XDECREF(__pyx_v_bullet_x);
  __Pyx_XDECREF(__pyx_v_bullet_y);
  __Pyx_XDECREF(__pyx_v_vx);
  __Pyx_XDECREF(__pyx_v_vy);
  __Pyx_XDECREF((PyObject *)__pyx_v_initial_timestep_fire_bullet);
  __Pyx_XDECREF(__pyx_v_bullet_fired_from_ship_heading);
  __Pyx_XDECREF(__pyx_v_bullet_fired_from_ship_position);
  __Pyx_XDECREF(__pyx_v_thrust);
  __Pyx_XDECREF(__pyx_v_turn_rate);
  __Pyx_XDECREF(__pyx_v_drag_amount);
  __Pyx_XDECREF(__pyx_v_b_idx);
  __Pyx_XDECREF(__pyx_v_b_tail);
  __Pyx_XDECREF(__pyx_v_a_idx);
  __Pyx_XDECREF(__pyx_v_mine_remove_idxs);
  __Pyx_XDECREF(__pyx_v_new_asteroids);
  __Pyx_XDECREF(__pyx_v_mine);
  __Pyx_XDECREF(__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_separation);
  __Pyx_XDECREF(__pyx_v_ship_position);
  __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_a);
  __Pyx_XDECREF(__pyx_9genexpr37__pyx_v_a);
  __Pyx_XDECREF(__pyx_9genexpr38__pyx_v_m);
  __Pyx_XDECREF(__pyx_9genexpr39__pyx_v_b);
  __Pyx_XDECREF(__pyx_9genexpr40__pyx_v_ast_list);
  __Pyx_XDECREF(__pyx_9genexpr40__pyx_v_ast);
  __Pyx_XDECREF(__pyx_9genexpr41__pyx_v_bullet);
  __Pyx_XDECREF(__pyx_9genexpr42__pyx_v_bullet);
  __Pyx_XDECREF(__pyx_9genexpr43__pyx_v_mine);
  __Pyx_XDECREF(__pyx_9genexpr44__pyx_v_idx);
  __Pyx_XDECREF(__pyx_9genexpr44__pyx_v_asteroid);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_kp_u_Optional_Ship) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fire_after_timesteps, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_skip_half_of_first_cycle, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_current_move_index, __pyx_mstate_global->__pyx_kp_u_Optional_int) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_whole_move_sequence, __pyx_mstate_global->__pyx_kp_u_Optional_list_Action) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_timestep_limit, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids_to_check, __pyx_mstate_global->__pyx_kp_u_Optional_list_Asteroid) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_Optional_Asteroid_int_bool) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_49bullet_sim, 0, __pyx_mstate_global->__pyx_n_u_Matrix_bullet_sim, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[170])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_defaults1)) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_INT_INF); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (!(likely(PyLong_CheckExact(__pyx_t_9))||((__pyx_t_9) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_9))) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_t_3)->arg0 = ((PyObject*)__pyx_t_9);
  __Pyx_GIVEREF(__pyx_t_9);
  __pyx_t_9 = 0;
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_3, __pyx_pf_14neo_controller_161__defaults__);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bullet_sim, __pyx_t_3) < 0) __PYX_ERR(0, 4583, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 4584:         # This simulates shooting at an asteroid to tell us whether we'll hit it, when we hit it, and which asteroid we hit (since we might hit an asteroid between us and our intended target)

 4585:         # I know there's lots of code duplication between this and update(), but there really are many differences in the way the update cycle is handled and it's very interleaved with the duplicated simulation code, so I ain't touching this lol

 4586:         # Assume we shoot on the next timestep, so we'll create a bullet and then track it and simulate it to see what it hits, if anything

 4587:         # This sim doesn't modify the state of the simulation class. Everything here is discarded after the sim is over, and this is just to see what my bullet hits, if anything.

 4588: 

 4589:         # Do the shallowest copies that we can get away with. copy.deepcopy is super slow so we avoid it

 4590:         #asteroids: list[Asteroid]

+4591:         if asteroids_to_check is not None:

  __pyx_t_1 = (__pyx_v_asteroids_to_check != ((PyObject*)Py_None));
  if (__pyx_t_1) {
/* … */
    goto __pyx_L3;
  }

+4592:             asteroids = cast(list[Asteroid], [a.copy() for a in asteroids_to_check])

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4592, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)(&PyList_Type)), ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4592, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    { /* enter inner scope */
      __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4592, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_6);
      if (unlikely(__pyx_v_asteroids_to_check == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
        __PYX_ERR(0, 4592, __pyx_L6_error)
      }
      __pyx_t_7 = __pyx_v_asteroids_to_check; __Pyx_INCREF(__pyx_t_7);
      __pyx_t_8 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4592, __pyx_L6_error)
          #endif
          if (__pyx_t_8 >= __pyx_temp) break;
        }
        __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_8);
        ++__pyx_t_8;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4592, __pyx_L6_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_XDECREF_SET(__pyx_9genexpr36__pyx_v_a, __pyx_t_9);
        __pyx_t_9 = 0;
        __pyx_t_10 = __pyx_9genexpr36__pyx_v_a;
        __Pyx_INCREF(__pyx_t_10);
        __pyx_t_11 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
          __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4592, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 4592, __pyx_L6_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_a); __pyx_9genexpr36__pyx_v_a = 0;
      goto __pyx_L10_exit_scope;
      __pyx_L6_error:;
      __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_a); __pyx_9genexpr36__pyx_v_a = 0;
      goto __pyx_L1_error;
      __pyx_L10_exit_scope:;
    } /* exit inner scope */
    __pyx_t_11 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_11 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_5, __pyx_t_6};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4592, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_v_asteroids = __pyx_t_2;
    __pyx_t_2 = 0;

 4593:         else:

+4594:             asteroids = cast(list[Asteroid], [a.copy() for a in self.game_state.asteroids])

  /*else*/ {
    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4594, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)(&PyList_Type)), ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Asteroid)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4594, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    { /* enter inner scope */
      __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4594, __pyx_L13_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4594, __pyx_L13_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4594, __pyx_L13_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
        __pyx_t_7 = __pyx_t_9; __Pyx_INCREF(__pyx_t_7);
        __pyx_t_8 = 0;
        __pyx_t_12 = NULL;
      } else {
        __pyx_t_8 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4594, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4594, __pyx_L13_error)
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      for (;;) {
        if (likely(!__pyx_t_12)) {
          if (likely(PyList_CheckExact(__pyx_t_7))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4594, __pyx_L13_error)
              #endif
              if (__pyx_t_8 >= __pyx_temp) break;
            }
            __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_8);
            ++__pyx_t_8;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4594, __pyx_L13_error)
              #endif
              if (__pyx_t_8 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_8));
            #else
            __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_8);
            #endif
            ++__pyx_t_8;
          }
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4594, __pyx_L13_error)
        } else {
          __pyx_t_9 = __pyx_t_12(__pyx_t_7);
          if (unlikely(!__pyx_t_9)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4594, __pyx_L13_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_XDECREF_SET(__pyx_9genexpr37__pyx_v_a, __pyx_t_9);
        __pyx_t_9 = 0;
        __pyx_t_10 = __pyx_9genexpr37__pyx_v_a;
        __Pyx_INCREF(__pyx_t_10);
        __pyx_t_11 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
          __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4594, __pyx_L13_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 4594, __pyx_L13_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_9genexpr37__pyx_v_a); __pyx_9genexpr37__pyx_v_a = 0;
      goto __pyx_L17_exit_scope;
      __pyx_L13_error:;
      __Pyx_XDECREF(__pyx_9genexpr37__pyx_v_a); __pyx_9genexpr37__pyx_v_a = 0;
      goto __pyx_L1_error;
      __pyx_L17_exit_scope:;
    } /* exit inner scope */
    __pyx_t_11 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_11 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4594, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_v_asteroids = __pyx_t_2;
    __pyx_t_2 = 0;
  }
  __pyx_L3:;

+4595:         mines: list[Mine] = cast(list[Mine], [m.copy() for m in self.game_state.mines])

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4595, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)(&PyList_Type)), ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Mine)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4595, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  { /* enter inner scope */
    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4595, __pyx_L20_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4595, __pyx_L20_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4595, __pyx_L20_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
      __pyx_t_7 = __pyx_t_9; __Pyx_INCREF(__pyx_t_7);
      __pyx_t_8 = 0;
      __pyx_t_12 = NULL;
    } else {
      __pyx_t_8 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4595, __pyx_L20_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4595, __pyx_L20_error)
    }
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    for (;;) {
      if (likely(!__pyx_t_12)) {
        if (likely(PyList_CheckExact(__pyx_t_7))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4595, __pyx_L20_error)
            #endif
            if (__pyx_t_8 >= __pyx_temp) break;
          }
          __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_8);
          ++__pyx_t_8;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4595, __pyx_L20_error)
            #endif
            if (__pyx_t_8 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_8));
          #else
          __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_8);
          #endif
          ++__pyx_t_8;
        }
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4595, __pyx_L20_error)
      } else {
        __pyx_t_9 = __pyx_t_12(__pyx_t_7);
        if (unlikely(!__pyx_t_9)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4595, __pyx_L20_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_XDECREF_SET(__pyx_9genexpr38__pyx_v_m, __pyx_t_9);
      __pyx_t_9 = 0;
      __pyx_t_10 = __pyx_9genexpr38__pyx_v_m;
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_11 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
        __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4595, __pyx_L20_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 4595, __pyx_L20_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    }
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_9genexpr38__pyx_v_m); __pyx_9genexpr38__pyx_v_m = 0;
    goto __pyx_L24_exit_scope;
    __pyx_L20_error:;
    __Pyx_XDECREF(__pyx_9genexpr38__pyx_v_m); __pyx_9genexpr38__pyx_v_m = 0;
    goto __pyx_L1_error;
    __pyx_L24_exit_scope:;
  } /* exit inner scope */
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_5, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4595, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (!(likely(PyList_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_2))) __PYX_ERR(0, 4595, __pyx_L1_error)
  __pyx_v_mines = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+4596:         bullets: list[Bullet] = cast(list[Bullet], [b.copy() for b in self.game_state.bullets])

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)(&PyList_Type)), ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  { /* enter inner scope */
    __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4596, __pyx_L27_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4596, __pyx_L27_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4596, __pyx_L27_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
      __pyx_t_7 = __pyx_t_9; __Pyx_INCREF(__pyx_t_7);
      __pyx_t_8 = 0;
      __pyx_t_12 = NULL;
    } else {
      __pyx_t_8 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4596, __pyx_L27_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4596, __pyx_L27_error)
    }
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    for (;;) {
      if (likely(!__pyx_t_12)) {
        if (likely(PyList_CheckExact(__pyx_t_7))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4596, __pyx_L27_error)
            #endif
            if (__pyx_t_8 >= __pyx_temp) break;
          }
          __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_8);
          ++__pyx_t_8;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4596, __pyx_L27_error)
            #endif
            if (__pyx_t_8 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_8));
          #else
          __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_8);
          #endif
          ++__pyx_t_8;
        }
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4596, __pyx_L27_error)
      } else {
        __pyx_t_9 = __pyx_t_12(__pyx_t_7);
        if (unlikely(!__pyx_t_9)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4596, __pyx_L27_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_XDECREF_SET(__pyx_9genexpr39__pyx_v_b, __pyx_t_9);
      __pyx_t_9 = 0;
      __pyx_t_10 = __pyx_9genexpr39__pyx_v_b;
      __Pyx_INCREF(__pyx_t_10);
      __pyx_t_11 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
        __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4596, __pyx_L27_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 4596, __pyx_L27_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    }
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_9genexpr39__pyx_v_b); __pyx_9genexpr39__pyx_v_b = 0;
    goto __pyx_L31_exit_scope;
    __pyx_L27_error:;
    __Pyx_XDECREF(__pyx_9genexpr39__pyx_v_b); __pyx_9genexpr39__pyx_v_b = 0;
    goto __pyx_L1_error;
    __pyx_L31_exit_scope:;
  } /* exit inner scope */
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_5, __pyx_t_6};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4596, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (!(likely(PyList_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_2))) __PYX_ERR(0, 4596, __pyx_L1_error)
  __pyx_v_bullets = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+4597:         initial_ship_state = self.get_ship_state()

  __pyx_t_4 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_11 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_ship_state, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4597, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_initial_ship_state = __pyx_t_2;
  __pyx_t_2 = 0;

+4598:         if ship_state and ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __pyx_t_13 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_ship_state)); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4598, __pyx_L1_error)
  if (__pyx_t_13) {
  } else {
    __pyx_t_1 = __pyx_t_13;
    goto __pyx_L33_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4598, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4598, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_1 = __pyx_t_13;
  __pyx_L33_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+4599:             assert check_coordinate_bounds(self.game_state, ship_state.position[0], ship_state.position[1])  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_4 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4599, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_4);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_t_5, __pyx_t_7, __pyx_t_9};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4599, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4599, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4599, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4599, __pyx_L1_error)
    #endif

+4600:         if whole_move_sequence:

  __pyx_t_1 = (__pyx_v_whole_move_sequence != Py_None)&&(__Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 4600, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
    goto __pyx_L35;
  }

+4601:             bullet_sim_ship_state = self.get_ship_state()

    __pyx_t_6 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_11 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_ship_state, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4601, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_v_bullet_sim_ship_state = __pyx_t_2;
    __pyx_t_2 = 0;

 4602:         else:

+4603:             bullet_sim_ship_state = None

  /*else*/ {
    __Pyx_INCREF(Py_None);
    __pyx_v_bullet_sim_ship_state = Py_None;
  }
  __pyx_L35:;

+4604:         my_bullet: Optional[Bullet] = None

  __Pyx_INCREF(Py_None);
  __pyx_v_my_bullet = ((struct __pyx_obj_14neo_controller_Bullet *)Py_None);

+4605:         ship_not_collided_with_asteroid: bool = True

  __pyx_v_ship_not_collided_with_asteroid = 1;

 4606:         timesteps_until_bullet_hit_asteroid: int

+4607:         if skip_half_of_first_cycle:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4607, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
    goto __pyx_L36;
  }

+4608:             timesteps_until_bullet_hit_asteroid = -1

    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
    __pyx_v_timesteps_until_bullet_hit_asteroid = __pyx_mstate_global->__pyx_int_neg_1;

 4609:         else:

+4610:             timesteps_until_bullet_hit_asteroid = 0

  /*else*/ {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_v_timesteps_until_bullet_hit_asteroid = __pyx_mstate_global->__pyx_int_0;
  }
  __pyx_L36:;

 4611:         # Keep iterating until our bullet flies off the edge of the screen, or it hits an asteroid

 4612:         #global total_bullet_sim_timesteps

 4613:         #global total_bullet_sim_iterations

 4614:         #total_bullet_sim_iterations += 1

+4615:         asteroid_remove_idxs: set[int] = set()

  __pyx_t_2 = PySet_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4615, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_asteroid_remove_idxs = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 4616:         global total_sim_timesteps  # REMOVE_FOR_COMPETITION

 4617:         #global bullet_sim_time

 4618:         #start_time = time.perf_counter()

+4619:         while True:

  while (1) {

 4620:             #total_bullet_sim_timesteps += 1

+4621:             total_sim_timesteps += 1  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_total_sim_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4621, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4621, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_total_sim_timesteps, __pyx_t_6) < 0) __PYX_ERR(0, 4621, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 4622:             # Simplified update() simulation loop

+4623:             timesteps_until_bullet_hit_asteroid += 1

    __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4623, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF_SET(__pyx_v_timesteps_until_bullet_hit_asteroid, ((PyObject*)__pyx_t_6));
    __pyx_t_6 = 0;

+4624:             if timesteps_until_bullet_hit_asteroid > timestep_limit:

    __pyx_t_6 = PyObject_RichCompare(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_v_timestep_limit, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4624, __pyx_L1_error)
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4624, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_1) {
/* … */
    }

 4625:                 #bullet_sim_time += time.perf_counter() - start_time

+4626:                 return None, int(-1), ship_not_collided_with_asteroid

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_6 = __Pyx_PyNumber_Int(__pyx_mstate_global->__pyx_int_neg_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4626, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_ship_not_collided_with_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4626, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4626, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_INCREF(Py_None);
      __Pyx_GIVEREF(Py_None);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, Py_None) != (0)) __PYX_ERR(0, 4626, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_6);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 4626, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_2);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_t_2) != (0)) __PYX_ERR(0, 4626, __pyx_L1_error);
      __pyx_t_6 = 0;
      __pyx_t_2 = 0;
      __pyx_r = ((PyObject*)__pyx_t_9);
      __pyx_t_9 = 0;
      goto __pyx_L0;

+4627:             if self.game_state_plotter is not None and (self.plot_this_sim or (GAMESTATE_PLOTTING and BULLET_SIM_PLOTTING and (START_GAMESTATE_PLOTTING_AT_SECOND is None or START_GAMESTATE_PLOTTING_AT_SECOND*FPS <= float(self.initial_timestep + timesteps_until_bullet_hit_asteroid + (-1 if not skip_half_of_first_cycle else 0))))):  # REMOVE_FOR_COMPETITION

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_13 = (__pyx_t_9 != Py_None);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_13) {
    } else {
      __pyx_t_1 = __pyx_t_13;
      goto __pyx_L41_bool_binop_done;
    }
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_plot_this_sim); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (!__pyx_t_13) {
    } else {
      __pyx_t_1 = __pyx_t_13;
      goto __pyx_L41_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_GAMESTATE_PLOTTING); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_13) {
    } else {
      __pyx_t_1 = __pyx_t_13;
      goto __pyx_L41_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_BULLET_SIM_PLOTTING); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_13) {
    } else {
      __pyx_t_1 = __pyx_t_13;
      goto __pyx_L41_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_13 = (__pyx_t_9 == Py_None);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (!__pyx_t_13) {
    } else {
      __pyx_t_1 = __pyx_t_13;
      goto __pyx_L41_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_9 = PyNumber_Add(__pyx_t_2, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4627, __pyx_L1_error)
    __pyx_t_14 = (!__pyx_t_13);
    if (__pyx_t_14) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
      __pyx_t_2 = __pyx_mstate_global->__pyx_int_neg_1;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
    }
    __pyx_t_7 = PyNumber_Add(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyNumber_Float(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4627, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_1 = __pyx_t_14;
    __pyx_L41_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+4628:                 flattened_asteroids_pending_death = [ast for ast_list in self.asteroids_pending_death.values() for ast in ast_list]  # REMOVE_FOR_COMPETITION

      { /* enter inner scope */
        __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4628, __pyx_L49_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_8 = 0;
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4628, __pyx_L49_error)
        __Pyx_GOTREF(__pyx_t_6);
        if (unlikely(__pyx_t_6 == Py_None)) {
          PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
          __PYX_ERR(0, 4628, __pyx_L49_error)
        }
        __pyx_t_9 = __Pyx_dict_iterator(__pyx_t_6, 0, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_15), (&__pyx_t_16)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4628, __pyx_L49_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_XDECREF(__pyx_t_2);
        __pyx_t_2 = __pyx_t_9;
        __pyx_t_9 = 0;
        while (1) {
          __pyx_t_17 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_15, &__pyx_t_8, NULL, &__pyx_t_9, NULL, __pyx_t_16);
          if (unlikely(__pyx_t_17 == 0)) break;
          if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 4628, __pyx_L49_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_XDECREF_SET(__pyx_9genexpr40__pyx_v_ast_list, __pyx_t_9);
          __pyx_t_9 = 0;
          if (likely(PyList_CheckExact(__pyx_9genexpr40__pyx_v_ast_list)) || PyTuple_CheckExact(__pyx_9genexpr40__pyx_v_ast_list)) {
            __pyx_t_9 = __pyx_9genexpr40__pyx_v_ast_list; __Pyx_INCREF(__pyx_t_9);
            __pyx_t_18 = 0;
            __pyx_t_12 = NULL;
          } else {
            __pyx_t_18 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_9genexpr40__pyx_v_ast_list); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4628, __pyx_L49_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4628, __pyx_L49_error)
          }
          for (;;) {
            if (likely(!__pyx_t_12)) {
              if (likely(PyList_CheckExact(__pyx_t_9))) {
                {
                  Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
                  #if !CYTHON_ASSUME_SAFE_SIZE
                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4628, __pyx_L49_error)
                  #endif
                  if (__pyx_t_18 >= __pyx_temp) break;
                }
                __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_18);
                ++__pyx_t_18;
              } else {
                {
                  Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
                  #if !CYTHON_ASSUME_SAFE_SIZE
                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4628, __pyx_L49_error)
                  #endif
                  if (__pyx_t_18 >= __pyx_temp) break;
                }
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                __pyx_t_6 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_18));
                #else
                __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_18);
                #endif
                ++__pyx_t_18;
              }
              if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4628, __pyx_L49_error)
            } else {
              __pyx_t_6 = __pyx_t_12(__pyx_t_9);
              if (unlikely(!__pyx_t_6)) {
                PyObject* exc_type = PyErr_Occurred();
                if (exc_type) {
                  if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4628, __pyx_L49_error)
                  PyErr_Clear();
                }
                break;
              }
            }
            __Pyx_GOTREF(__pyx_t_6);
            __Pyx_XDECREF_SET(__pyx_9genexpr40__pyx_v_ast, __pyx_t_6);
            __pyx_t_6 = 0;
            if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_9genexpr40__pyx_v_ast))) __PYX_ERR(0, 4628, __pyx_L49_error)
          }
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF(__pyx_9genexpr40__pyx_v_ast); __pyx_9genexpr40__pyx_v_ast = 0;
        __Pyx_XDECREF(__pyx_9genexpr40__pyx_v_ast_list); __pyx_9genexpr40__pyx_v_ast_list = 0;
        goto __pyx_L55_exit_scope;
        __pyx_L49_error:;
        __Pyx_XDECREF(__pyx_9genexpr40__pyx_v_ast); __pyx_9genexpr40__pyx_v_ast = 0;
        __Pyx_XDECREF(__pyx_9genexpr40__pyx_v_ast_list); __pyx_9genexpr40__pyx_v_ast_list = 0;
        goto __pyx_L1_error;
        __pyx_L55_exit_scope:;
      } /* exit inner scope */
      __Pyx_XDECREF_SET(__pyx_v_flattened_asteroids_pending_death, ((PyObject*)__pyx_t_7));
      __pyx_t_7 = 0;

 4629:                 ship_plot_state: Optional[Ship]  # REMOVE_FOR_COMPETITION

+4630:                 if whole_move_sequence:  # REMOVE_FOR_COMPETITION

      __pyx_t_1 = (__pyx_v_whole_move_sequence != Py_None)&&(__Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence) != 0);
      if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 4630, __pyx_L1_error)
      if (__pyx_t_1) {
/* … */
        goto __pyx_L56;
      }

+4631:                     ship_plot_state = bullet_sim_ship_state  # REMOVE_FOR_COMPETITION

        __pyx_t_7 = __pyx_v_bullet_sim_ship_state;
        __Pyx_INCREF(__pyx_t_7);
        if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship))))) __PYX_ERR(0, 4631, __pyx_L1_error)
        __Pyx_XDECREF_SET(__pyx_v_ship_plot_state, ((struct __pyx_obj_14neo_controller_Ship *)__pyx_t_7));
        __pyx_t_7 = 0;

 4632:                 else:  # REMOVE_FOR_COMPETITION

+4633:                     ship_plot_state = None  # REMOVE_FOR_COMPETITION

      /*else*/ {
        __Pyx_INCREF(Py_None);
        __Pyx_XDECREF_SET(__pyx_v_ship_plot_state, ((struct __pyx_obj_14neo_controller_Ship *)Py_None));
      }
      __pyx_L56:;

+4634:                 self.game_state_plotter.update_plot(asteroids, ship_plot_state, bullets, [my_bullet] if my_bullet is not None else [], [], flattened_asteroids_pending_death, self.forecasted_asteroid_splits, mines, True, EPS, f'SIM ID {self.sim_id} Ast count: {len(asteroids)} BULLET SIMULATION TIMESTEP {self.initial_timestep + timesteps_until_bullet_hit_asteroid}')  # REMOVE_FOR_COMPETITION

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_2 = __pyx_t_9;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_1 = (((PyObject *)__pyx_v_my_bullet) != Py_None);
      if (__pyx_t_1) {
        __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4634, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_INCREF((PyObject *)__pyx_v_my_bullet);
        __Pyx_GIVEREF((PyObject *)__pyx_v_my_bullet);
        if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_my_bullet)) != (0)) __PYX_ERR(0, 4634, __pyx_L1_error);
        __pyx_t_6 = __pyx_t_5;
        __pyx_t_5 = 0;
      } else {
        __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4634, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_6 = __pyx_t_5;
        __pyx_t_5 = 0;
      }
      __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sim_id); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_19 = __Pyx_PyObject_FormatSimple(__pyx_t_10, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_15 = PyObject_Length(__pyx_v_asteroids); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4634, __pyx_L1_error)
      __pyx_t_10 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_15, 0, ' ', 'd'); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_21 = PyNumber_Add(__pyx_t_20, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_20 = __Pyx_PyObject_FormatSimple(__pyx_t_21, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_22[0] = __pyx_mstate_global->__pyx_kp_u_SIM_ID;
      __pyx_t_22[1] = __pyx_t_19;
      __pyx_t_22[2] = __pyx_mstate_global->__pyx_kp_u_Ast_count;
      __pyx_t_22[3] = __pyx_t_10;
      __pyx_t_22[4] = __pyx_mstate_global->__pyx_kp_u_BULLET_SIMULATION_TIMESTEP;
      __pyx_t_22[5] = __pyx_t_20;
      __pyx_t_21 = __Pyx_PyUnicode_Join(__pyx_t_22, 6, 7 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19) + 12 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 28 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_20), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_19) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_20));
      if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4634, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_11 = 0;
      {
        PyObject *__pyx_callargs[12] = {__pyx_t_2, __pyx_v_asteroids, ((PyObject *)__pyx_v_ship_plot_state), __pyx_v_bullets, __pyx_t_6, __pyx_t_5, __pyx_v_flattened_asteroids_pending_death, __pyx_t_4, __pyx_v_mines, Py_True, __pyx_t_3, __pyx_t_21};
        __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update_plot, __pyx_callargs+__pyx_t_11, (12-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4634, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

 4635:             # Simulate bullets

+4636:             if not (skip_half_of_first_cycle and timesteps_until_bullet_hit_asteroid == 0):

    __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4636, __pyx_L1_error)
    if (__pyx_t_14) {
    } else {
      __pyx_t_1 = __pyx_t_14;
      goto __pyx_L58_bool_binop_done;
    }
    __pyx_t_14 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4636, __pyx_L1_error)
    __pyx_t_1 = __pyx_t_14;
    __pyx_L58_bool_binop_done:;
    __pyx_t_14 = (!__pyx_t_1);
    if (__pyx_t_14) {
/* … */
    }

+4637:                 bullet_remove_idxs: list[int] = []

      __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4637, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_XDECREF_SET(__pyx_v_bullet_remove_idxs, ((PyObject*)__pyx_t_7));
      __pyx_t_7 = 0;

+4638:                 for b_ind, b in enumerate(bullets):

      __pyx_t_15 = 0;
      __pyx_t_7 = __pyx_v_bullets; __Pyx_INCREF(__pyx_t_7);
      __pyx_t_8 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4638, __pyx_L1_error)
          #endif
          if (__pyx_t_8 >= __pyx_temp) break;
        }
        __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_8);
        ++__pyx_t_8;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4638, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_9);
        __pyx_t_9 = 0;
        __pyx_v_b_ind = __pyx_t_15;
        __pyx_t_15 = (__pyx_t_15 + 1);
/* … */
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+4639:                     new_bullet_pos = (b.position[0] + b.velocity[0]*DELTA_TIME, b.position[1] + b.velocity[1]*DELTA_TIME)

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_Add(__pyx_t_21, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = PyNumber_Add(__pyx_t_21, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4639, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_GIVEREF(__pyx_t_9);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_9) != (0)) __PYX_ERR(0, 4639, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_4);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 4639, __pyx_L1_error);
        __pyx_t_9 = 0;
        __pyx_t_4 = 0;
        __Pyx_XDECREF_SET(__pyx_v_new_bullet_pos, ((PyObject*)__pyx_t_5));
        __pyx_t_5 = 0;

+4640:                     if check_coordinate_bounds(self.game_state, new_bullet_pos[0], new_bullet_pos[1]):

        __pyx_t_4 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4640, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4640, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_11 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_9))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
          assert(__pyx_t_4);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
          __pyx_t_11 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_t_21, __Pyx_PyTuple_GET_ITEM(__pyx_v_new_bullet_pos, 0), __Pyx_PyTuple_GET_ITEM(__pyx_v_new_bullet_pos, 1)};
          __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4640, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
        }
        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4640, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (__pyx_t_14) {
/* … */
          goto __pyx_L62;
        }

+4641:                         b.position = new_bullet_pos

          if (__Pyx_PyObject_SetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position, __pyx_v_new_bullet_pos) < 0) __PYX_ERR(0, 4641, __pyx_L1_error)

 4642:                     else:

+4643:                         bullet_remove_idxs.append(b_ind)

        /*else*/ {
          __pyx_t_5 = PyLong_FromSsize_t(__pyx_v_b_ind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4643, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_23 = __Pyx_PyList_Append(__pyx_v_bullet_remove_idxs, __pyx_t_5); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4643, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        }
        __pyx_L62:;

+4644:                 if bullet_remove_idxs:

      __pyx_t_14 = (__Pyx_PyList_GET_SIZE(__pyx_v_bullet_remove_idxs) != 0);
      if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_14 < 0))) __PYX_ERR(0, 4644, __pyx_L1_error)
      if (__pyx_t_14) {
/* … */
      }

+4645:                     bullets = [bullet for idx, bullet in enumerate(bullets) if idx not in bullet_remove_idxs]

        { /* enter inner scope */
          __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4645, __pyx_L67_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_15 = 0;
          __pyx_t_5 = __pyx_v_bullets; __Pyx_INCREF(__pyx_t_5);
          __pyx_t_8 = 0;
          for (;;) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4645, __pyx_L67_error)
              #endif
              if (__pyx_t_8 >= __pyx_temp) break;
            }
            __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_8);
            ++__pyx_t_8;
            if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4645, __pyx_L67_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_XDECREF_SET(__pyx_9genexpr41__pyx_v_bullet, __pyx_t_9);
            __pyx_t_9 = 0;
            __pyx_9genexpr41__pyx_v_idx = __pyx_t_15;
            __pyx_t_15 = (__pyx_t_15 + 1);
            __pyx_t_9 = PyLong_FromSsize_t(__pyx_9genexpr41__pyx_v_idx); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4645, __pyx_L67_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_14 = (__Pyx_PySequence_ContainsTF(__pyx_t_9, __pyx_v_bullet_remove_idxs, Py_NE)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4645, __pyx_L67_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (__pyx_t_14) {
              if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_9genexpr41__pyx_v_bullet))) __PYX_ERR(0, 4645, __pyx_L67_error)
            }
          }
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_XDECREF(__pyx_9genexpr41__pyx_v_bullet); __pyx_9genexpr41__pyx_v_bullet = 0;
          goto __pyx_L72_exit_scope;
          __pyx_L67_error:;
          __Pyx_XDECREF(__pyx_9genexpr41__pyx_v_bullet); __pyx_9genexpr41__pyx_v_bullet = 0;
          goto __pyx_L1_error;
          __pyx_L72_exit_scope:;
        } /* exit inner scope */
        __Pyx_DECREF_SET(__pyx_v_bullets, ((PyObject*)__pyx_t_7));
        __pyx_t_7 = 0;

+4646:                 if my_bullet is not None:

      __pyx_t_14 = (((PyObject *)__pyx_v_my_bullet) != Py_None);
      if (__pyx_t_14) {
/* … */
      }

+4647:                     my_new_bullet_pos = (my_bullet.position[0] + my_bullet.velocity[0]*DELTA_TIME, my_bullet.position[1] + my_bullet.velocity[1]*DELTA_TIME)

        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_my_bullet), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_my_bullet), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_21 = PyNumber_Multiply(__pyx_t_9, __pyx_t_7); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_7 = PyNumber_Add(__pyx_t_5, __pyx_t_21); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_my_bullet), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_21, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_my_bullet), __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_21, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_4 = PyNumber_Multiply(__pyx_t_9, __pyx_t_21); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_7);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 4647, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_21);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_21) != (0)) __PYX_ERR(0, 4647, __pyx_L1_error);
        __pyx_t_7 = 0;
        __pyx_t_21 = 0;
        __Pyx_XDECREF_SET(__pyx_v_my_new_bullet_pos, ((PyObject*)__pyx_t_4));
        __pyx_t_4 = 0;

+4648:                     if check_coordinate_bounds(self.game_state, my_new_bullet_pos[0], my_new_bullet_pos[1]):

        __pyx_t_21 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4648, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4648, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_11 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_7))) {
          __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7);
          assert(__pyx_t_21);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
          __Pyx_INCREF(__pyx_t_21);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
          __pyx_t_11 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_21, __pyx_t_5, __Pyx_PyTuple_GET_ITEM(__pyx_v_my_new_bullet_pos, 0), __Pyx_PyTuple_GET_ITEM(__pyx_v_my_new_bullet_pos, 1)};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4648, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4648, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (__pyx_t_14) {
/* … */
          goto __pyx_L74;
        }

+4649:                         my_bullet.position = my_new_bullet_pos

          if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_my_bullet), __pyx_mstate_global->__pyx_n_u_position, __pyx_v_my_new_bullet_pos) < 0) __PYX_ERR(0, 4649, __pyx_L1_error)

 4650:                     else:

 4651:                         #bullet_sim_time += time.perf_counter() - start_time

+4652:                         return None, int(-1), ship_not_collided_with_asteroid  # The bullet got shot into the void without hitting anything :(

        /*else*/ {
          __Pyx_XDECREF(__pyx_r);
          __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_mstate_global->__pyx_int_neg_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4652, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_ship_not_collided_with_asteroid); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4652, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4652, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_INCREF(Py_None);
          __Pyx_GIVEREF(Py_None);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, Py_None) != (0)) __PYX_ERR(0, 4652, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_4);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 4652, __pyx_L1_error);
          __Pyx_GIVEREF(__pyx_t_7);
          if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 4652, __pyx_L1_error);
          __pyx_t_4 = 0;
          __pyx_t_7 = 0;
          __pyx_r = ((PyObject*)__pyx_t_5);
          __pyx_t_5 = 0;
          goto __pyx_L0;
        }
        __pyx_L74:;

 4653: 

+4654:                 for m in mines:

      if (unlikely(__pyx_v_mines == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
        __PYX_ERR(0, 4654, __pyx_L1_error)
      }
      __pyx_t_5 = __pyx_v_mines; __Pyx_INCREF(__pyx_t_5);
      __pyx_t_15 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4654, __pyx_L1_error)
          #endif
          if (__pyx_t_15 >= __pyx_temp) break;
        }
        __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_15);
        ++__pyx_t_15;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4654, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_7);
        __pyx_t_7 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+4655:                     m.remaining_time -= DELTA_TIME

        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4655, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4655, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_21 = PyNumber_InPlaceSubtract(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4655, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time, __pyx_t_21) < 0) __PYX_ERR(0, 4655, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

 4656: 

+4657:                 for a in asteroids:

      if (likely(PyList_CheckExact(__pyx_v_asteroids)) || PyTuple_CheckExact(__pyx_v_asteroids)) {
        __pyx_t_5 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_5);
        __pyx_t_15 = 0;
        __pyx_t_12 = NULL;
      } else {
        __pyx_t_15 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_asteroids); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4657, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4657, __pyx_L1_error)
      }
      for (;;) {
        if (likely(!__pyx_t_12)) {
          if (likely(PyList_CheckExact(__pyx_t_5))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4657, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            __pyx_t_21 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_15);
            ++__pyx_t_15;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4657, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_21 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_15));
            #else
            __pyx_t_21 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_15);
            #endif
            ++__pyx_t_15;
          }
          if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4657, __pyx_L1_error)
        } else {
          __pyx_t_21 = __pyx_t_12(__pyx_t_5);
          if (unlikely(!__pyx_t_21)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4657, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_21);
        __pyx_t_21 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+4658:                     a.position = ((a.position[0] + a.velocity[0]*DELTA_TIME) % self.game_state.map_size[0], (a.position[1] + a.velocity[1]*DELTA_TIME) % self.game_state.map_size[1])

        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_21, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_21, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_9 = PyNumber_Multiply(__pyx_t_7, __pyx_t_21); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = PyNumber_Add(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = PyNumber_Remainder(__pyx_t_21, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_Add(__pyx_t_21, __pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_21, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = PyNumber_Remainder(__pyx_t_9, __pyx_t_3); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_GIVEREF(__pyx_t_4);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 4658, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_21);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_21) != (0)) __PYX_ERR(0, 4658, __pyx_L1_error);
        __pyx_t_4 = 0;
        __pyx_t_21 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position, __pyx_t_3) < 0) __PYX_ERR(0, 4658, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 4659: 

 4660:             # debug_print(f"TS ahead of sim end: {timesteps_until_bullet_hit_asteroid}")

 4661:             # debug_print(asteroids)

 4662:             # Create the initial bullet we fire, if we're locked in

+4663:             if fire_first_timestep and timesteps_until_bullet_hit_asteroid + (-1 if not skip_half_of_first_cycle else 0) == 0:

    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_fire_first_timestep); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4663, __pyx_L1_error)
    if (__pyx_t_1) {
    } else {
      __pyx_t_14 = __pyx_t_1;
      goto __pyx_L82_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4663, __pyx_L1_error)
    __pyx_t_13 = (!__pyx_t_1);
    if (__pyx_t_13) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
      __pyx_t_5 = __pyx_mstate_global->__pyx_int_neg_1;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_int_0;
    }
    __pyx_t_3 = PyNumber_Add(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4663, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_13 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4663, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_14 = __pyx_t_13;
    __pyx_L82_bool_binop_done:;
    if (__pyx_t_14) {
/* … */
    }

+4664:                 rad_heading = radians(initial_ship_state.heading)

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4664, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_initial_ship_state, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4664, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_21))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_21);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_21, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4664, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_XDECREF_SET(__pyx_v_rad_heading, __pyx_t_3);
      __pyx_t_3 = 0;

+4665:                 cos_heading = cos(rad_heading)

      __pyx_t_24 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_24 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4665, __pyx_L1_error)
      __pyx_v_cos_heading = cos(__pyx_t_24);

+4666:                 sin_heading = sin(rad_heading)

      __pyx_t_24 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_24 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4666, __pyx_L1_error)
      __pyx_v_sin_heading = sin(__pyx_t_24);

+4667:                 bullet_x = initial_ship_state.position[0] + SHIP_RADIUS*cos_heading

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_initial_ship_state, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyNumber_Add(__pyx_t_21, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF_SET(__pyx_v_bullet_x, __pyx_t_4);
      __pyx_t_4 = 0;

+4668:                 bullet_y = initial_ship_state.position[1] + SHIP_RADIUS*sin_heading

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_initial_ship_state, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4668, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4668, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4668, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_21 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4668, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_3 = PyNumber_Multiply(__pyx_t_4, __pyx_t_21); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4668, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_21 = PyNumber_Add(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4668, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF_SET(__pyx_v_bullet_y, __pyx_t_21);
      __pyx_t_21 = 0;

 4669:                 # Make sure the bullet isn't being fired out into the void

+4670:                 if check_coordinate_bounds(self.game_state, bullet_x, bullet_y):

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4670, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4670, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_t_4, __pyx_v_bullet_x, __pyx_v_bullet_y};
        __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4670, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
      }
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4670, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      if (__pyx_t_14) {
/* … */
      }

+4671:                     vx = BULLET_SPEED*cos_heading

        __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4671, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_5 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4671, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_4 = PyNumber_Multiply(__pyx_t_21, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4671, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_vx, __pyx_t_4);
        __pyx_t_4 = 0;

+4672:                     vy = BULLET_SPEED*sin_heading

        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4672, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_5 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4672, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_21 = PyNumber_Multiply(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4672, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_vy, __pyx_t_21);
        __pyx_t_21 = 0;

+4673:                     initial_timestep_fire_bullet = Bullet(

        __pyx_t_5 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet);
        __pyx_t_4 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet); 

+4674:                         position=(bullet_x, bullet_y),

        __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4674, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_INCREF(__pyx_v_bullet_x);
        __Pyx_GIVEREF(__pyx_v_bullet_x);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_bullet_x) != (0)) __PYX_ERR(0, 4674, __pyx_L1_error);
        __Pyx_INCREF(__pyx_v_bullet_y);
        __Pyx_GIVEREF(__pyx_v_bullet_y);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_bullet_y) != (0)) __PYX_ERR(0, 4674, __pyx_L1_error);

+4675:                         velocity=(vx, vy),

        __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4675, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_INCREF(__pyx_v_vx);
        __Pyx_GIVEREF(__pyx_v_vx);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_vx) != (0)) __PYX_ERR(0, 4675, __pyx_L1_error);
        __Pyx_INCREF(__pyx_v_vy);
        __Pyx_GIVEREF(__pyx_v_vy);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_v_vy) != (0)) __PYX_ERR(0, 4675, __pyx_L1_error);

+4676:                         heading=initial_ship_state.heading,

        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_initial_ship_state, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4676, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);

+4677:                         mass=BULLET_MASS,

        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4677, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);

+4678:                         tail_delta=(-BULLET_LENGTH*cos_heading, -BULLET_LENGTH*sin_heading)

        __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_20 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_10 = PyNumber_Multiply(__pyx_t_20, __pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_20 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_19 = PyNumber_Multiply(__pyx_t_20, __pyx_t_2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4678, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_GIVEREF(__pyx_t_10);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_10) != (0)) __PYX_ERR(0, 4678, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_19);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_19) != (0)) __PYX_ERR(0, 4678, __pyx_L1_error);
        __pyx_t_10 = 0;
        __pyx_t_19 = 0;
        __pyx_t_11 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_5, NULL};
          __pyx_t_19 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4673, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_3, __pyx_t_19, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4673, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_9, __pyx_t_19, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4673, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_heading, __pyx_t_7, __pyx_t_19, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 4673, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_6, __pyx_t_19, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 4673, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_tail_delta, __pyx_t_2, __pyx_t_19, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 4673, __pyx_L1_error)
          __pyx_t_21 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_19);
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4673, __pyx_L1_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_21);
        }
        __Pyx_XDECREF_SET(__pyx_v_initial_timestep_fire_bullet, ((struct __pyx_obj_14neo_controller_Bullet *)__pyx_t_21));
        __pyx_t_21 = 0;

 4679:                     )

+4680:                     bullets.append(initial_timestep_fire_bullet)

        if (unlikely(__pyx_v_bullets == Py_None)) {
          PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
          __PYX_ERR(0, 4680, __pyx_L1_error)
        }
        __pyx_t_23 = __Pyx_PyList_Append(__pyx_v_bullets, ((PyObject *)__pyx_v_initial_timestep_fire_bullet)); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4680, __pyx_L1_error)

 4681:             # The new bullet we create will end up at the end of the list of bullets

+4682:             if my_bullet is None and timesteps_until_bullet_hit_asteroid + (-1 if not skip_half_of_first_cycle else 0) == fire_after_timesteps:

    __pyx_t_13 = (((PyObject *)__pyx_v_my_bullet) == Py_None);
    if (__pyx_t_13) {
    } else {
      __pyx_t_14 = __pyx_t_13;
      goto __pyx_L86_bool_binop_done;
    }
    __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 4682, __pyx_L1_error)
    __pyx_t_1 = (!__pyx_t_13);
    if (__pyx_t_1) {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
      __pyx_t_21 = __pyx_mstate_global->__pyx_int_neg_1;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_21 = __pyx_mstate_global->__pyx_int_0;
    }
    __pyx_t_4 = PyNumber_Add(__pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_21); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4682, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    __pyx_t_21 = PyObject_RichCompare(__pyx_t_4, __pyx_v_fire_after_timesteps, Py_EQ); __Pyx_XGOTREF(__pyx_t_21); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4682, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4682, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    __pyx_t_14 = __pyx_t_1;
    __pyx_L86_bool_binop_done:;
    if (__pyx_t_14) {
/* … */
    }

+4683:                 if ship_state is not None:

      __pyx_t_14 = (((PyObject *)__pyx_v_ship_state) != Py_None);
      if (__pyx_t_14) {
/* … */
        goto __pyx_L88;
      }

+4684:                     bullet_fired_from_ship_heading = ship_state.heading

        __pyx_t_21 = PyFloat_FromDouble(__pyx_v_ship_state->heading); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4684, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_XDECREF_SET(__pyx_v_bullet_fired_from_ship_heading, __pyx_t_21);
        __pyx_t_21 = 0;

+4685:                     bullet_fired_from_ship_position = ship_state.position

        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4685, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_XDECREF_SET(__pyx_v_bullet_fired_from_ship_position, __pyx_t_21);
        __pyx_t_21 = 0;

 4686:                 else:

+4687:                     bullet_fired_from_ship_heading = self.ship_state.heading

      /*else*/ {
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4687, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4687, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_XDECREF_SET(__pyx_v_bullet_fired_from_ship_heading, __pyx_t_4);
        __pyx_t_4 = 0;

+4688:                     bullet_fired_from_ship_position = self.ship_state.position

        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4688, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4688, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF_SET(__pyx_v_bullet_fired_from_ship_position, __pyx_t_21);
        __pyx_t_21 = 0;
      }
      __pyx_L88:;

+4689:                 rad_heading = radians(bullet_fired_from_ship_heading)

      __pyx_t_4 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4689, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_19))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_19);
        assert(__pyx_t_4);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_19, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_bullet_fired_from_ship_heading};
        __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4689, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
      }
      __Pyx_XDECREF_SET(__pyx_v_rad_heading, __pyx_t_21);
      __pyx_t_21 = 0;

+4690:                 cos_heading = cos(rad_heading)

      __pyx_t_24 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_24 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4690, __pyx_L1_error)
      __pyx_v_cos_heading = cos(__pyx_t_24);

+4691:                 sin_heading = sin(rad_heading)

      __pyx_t_24 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_24 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4691, __pyx_L1_error)
      __pyx_v_sin_heading = sin(__pyx_t_24);

+4692:                 bullet_x = bullet_fired_from_ship_position[0] + SHIP_RADIUS*cos_heading

      __pyx_t_21 = __Pyx_GetItemInt(__pyx_v_bullet_fired_from_ship_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4692, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4692, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4692, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = PyNumber_Multiply(__pyx_t_19, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4692, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyNumber_Add(__pyx_t_21, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4692, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF_SET(__pyx_v_bullet_x, __pyx_t_4);
      __pyx_t_4 = 0;

+4693:                 bullet_y = bullet_fired_from_ship_position[1] + SHIP_RADIUS*sin_heading

      __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_bullet_fired_from_ship_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4693, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4693, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_21 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4693, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_19 = PyNumber_Multiply(__pyx_t_2, __pyx_t_21); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4693, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_21 = PyNumber_Add(__pyx_t_4, __pyx_t_19); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4693, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __Pyx_XDECREF_SET(__pyx_v_bullet_y, __pyx_t_21);
      __pyx_t_21 = 0;

 4694:                 # Make sure the bullet isn't being fired out into the void

+4695:                 if not check_coordinate_bounds(self.game_state, bullet_x, bullet_y):

      __pyx_t_19 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4695, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4695, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_11 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_19);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_19);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_11 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_19, __pyx_t_2, __pyx_v_bullet_x, __pyx_v_bullet_y};
        __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4695, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
      }
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4695, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_1 = (!__pyx_t_14);
      if (__pyx_t_1) {
/* … */
      }

 4696:                     #bullet_sim_time += time.perf_counter() - start_time

+4697:                     return None, int(-1), ship_not_collided_with_asteroid  # The bullet got shot into the void without hitting anything :(

        __Pyx_XDECREF(__pyx_r);
        __pyx_t_21 = __Pyx_PyNumber_Int(__pyx_mstate_global->__pyx_int_neg_1); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4697, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_ship_not_collided_with_asteroid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4697, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4697, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_INCREF(Py_None);
        __Pyx_GIVEREF(Py_None);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, Py_None) != (0)) __PYX_ERR(0, 4697, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_21);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_21) != (0)) __PYX_ERR(0, 4697, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_4);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_4) != (0)) __PYX_ERR(0, 4697, __pyx_L1_error);
        __pyx_t_21 = 0;
        __pyx_t_4 = 0;
        __pyx_r = ((PyObject*)__pyx_t_2);
        __pyx_t_2 = 0;
        goto __pyx_L0;

+4698:                 vx = BULLET_SPEED*cos_heading

      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4698, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4698, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_21 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4698, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF_SET(__pyx_v_vx, __pyx_t_21);
      __pyx_t_21 = 0;

+4699:                 vy = BULLET_SPEED*sin_heading

      __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4699, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4699, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = PyNumber_Multiply(__pyx_t_21, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4699, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF_SET(__pyx_v_vy, __pyx_t_2);
      __pyx_t_2 = 0;

+4700:                 my_bullet = Bullet(

      __pyx_t_4 = NULL;
      __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet);
      __pyx_t_21 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet); 

+4701:                     position=(bullet_x, bullet_y),

      __pyx_t_19 = PyTuple_New(2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4701, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_INCREF(__pyx_v_bullet_x);
      __Pyx_GIVEREF(__pyx_v_bullet_x);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_v_bullet_x) != (0)) __PYX_ERR(0, 4701, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_bullet_y);
      __Pyx_GIVEREF(__pyx_v_bullet_y);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_19, 1, __pyx_v_bullet_y) != (0)) __PYX_ERR(0, 4701, __pyx_L1_error);

+4702:                     velocity=(vx, vy),

      __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_INCREF(__pyx_v_vx);
      __Pyx_GIVEREF(__pyx_v_vx);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_vx) != (0)) __PYX_ERR(0, 4702, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_vy);
      __Pyx_GIVEREF(__pyx_v_vy);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_vy) != (0)) __PYX_ERR(0, 4702, __pyx_L1_error);

 4703:                     heading=bullet_fired_from_ship_heading,

+4704:                     mass=BULLET_MASS,

      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4704, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);

+4705:                     tail_delta=(-BULLET_LENGTH*cos_heading, -BULLET_LENGTH*sin_heading)

      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_3 = PyNumber_Negative(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_3 = PyNumber_Negative(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = PyNumber_Multiply(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_GIVEREF(__pyx_t_5);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4705, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_10);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 4705, __pyx_L1_error);
      __pyx_t_5 = 0;
      __pyx_t_10 = 0;
      __pyx_t_11 = 1;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_4, NULL};
        __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4700, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_19, __pyx_t_10, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4700, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_6, __pyx_t_10, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4700, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_heading, __pyx_v_bullet_fired_from_ship_heading, __pyx_t_10, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 4700, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_7, __pyx_t_10, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 4700, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_tail_delta, __pyx_t_9, __pyx_t_10, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 4700, __pyx_L1_error)
        __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_21, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4700, __pyx_L1_error)
        __Pyx_GOTREF((PyObject *)__pyx_t_2);
      }
      __Pyx_DECREF_SET(__pyx_v_my_bullet, ((struct __pyx_obj_14neo_controller_Bullet *)__pyx_t_2));
      __pyx_t_2 = 0;

 4706:                 )

+4707:             if whole_move_sequence:

    __pyx_t_1 = (__pyx_v_whole_move_sequence != Py_None)&&(__Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence) != 0);
    if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 4707, __pyx_L1_error)
    if (__pyx_t_1) {
/* … */
    }

+4708:                 assert current_move_index is not None

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_1 = (__pyx_v_current_move_index != ((PyObject*)Py_None));
        if (unlikely(!__pyx_t_1)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 4708, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 4708, __pyx_L1_error)
      #endif

+4709:                 assert bullet_sim_ship_state is not None

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_1 = (__pyx_v_bullet_sim_ship_state != Py_None);
        if (unlikely(!__pyx_t_1)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 4709, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 4709, __pyx_L1_error)
      #endif

+4710:                 if current_move_index + timesteps_until_bullet_hit_asteroid + (-1 if not skip_half_of_first_cycle else 0) < len(whole_move_sequence):

      __pyx_t_2 = PyNumber_Add(__pyx_v_current_move_index, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4710, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4710, __pyx_L1_error)
      __pyx_t_14 = (!__pyx_t_1);
      if (__pyx_t_14) {
        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
        __pyx_t_21 = __pyx_mstate_global->__pyx_int_neg_1;
      } else {
        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __pyx_t_21 = __pyx_mstate_global->__pyx_int_0;
      }
      __pyx_t_10 = PyNumber_Add(__pyx_t_2, __pyx_t_21); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4710, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      if (unlikely(__pyx_v_whole_move_sequence == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
        __PYX_ERR(0, 4710, __pyx_L1_error)
      }
      __pyx_t_15 = __Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4710, __pyx_L1_error)
      __pyx_t_21 = PyLong_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4710, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_2 = PyObject_RichCompare(__pyx_t_10, __pyx_t_21, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4710, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4710, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (__pyx_t_14) {
/* … */
      }

 4711:                     # Simulate ship dynamics, if we have the full future list of moves to go off of

+4712:                     thrust = whole_move_sequence[current_move_index + timesteps_until_bullet_hit_asteroid + (-1 if not skip_half_of_first_cycle else 0)].thrust

        if (unlikely(__pyx_v_whole_move_sequence == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
          __PYX_ERR(0, 4712, __pyx_L1_error)
        }
        __pyx_t_2 = PyNumber_Add(__pyx_v_current_move_index, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4712, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4712, __pyx_L1_error)
        __pyx_t_1 = (!__pyx_t_14);
        if (__pyx_t_1) {
          __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
          __pyx_t_21 = __pyx_mstate_global->__pyx_int_neg_1;
        } else {
          __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
          __pyx_t_21 = __pyx_mstate_global->__pyx_int_0;
        }
        __pyx_t_10 = PyNumber_Add(__pyx_t_2, __pyx_t_21); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4712, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = __Pyx_PyObject_GetItem(__pyx_v_whole_move_sequence, __pyx_t_10); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4712, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_thrust); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4712, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_XDECREF_SET(__pyx_v_thrust, __pyx_t_10);
        __pyx_t_10 = 0;

+4713:                     turn_rate = whole_move_sequence[current_move_index + timesteps_until_bullet_hit_asteroid + (-1 if not skip_half_of_first_cycle else 0)].turn_rate

        if (unlikely(__pyx_v_whole_move_sequence == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
          __PYX_ERR(0, 4713, __pyx_L1_error)
        }
        __pyx_t_10 = PyNumber_Add(__pyx_v_current_move_index, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4713, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_skip_half_of_first_cycle); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4713, __pyx_L1_error)
        __pyx_t_14 = (!__pyx_t_1);
        if (__pyx_t_14) {
          __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
          __pyx_t_21 = __pyx_mstate_global->__pyx_int_neg_1;
        } else {
          __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
          __pyx_t_21 = __pyx_mstate_global->__pyx_int_0;
        }
        __pyx_t_2 = PyNumber_Add(__pyx_t_10, __pyx_t_21); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4713, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = __Pyx_PyObject_GetItem(__pyx_v_whole_move_sequence, __pyx_t_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4713, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_turn_rate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4713, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_XDECREF_SET(__pyx_v_turn_rate, __pyx_t_2);
        __pyx_t_2 = 0;

+4714:                     drag_amount = SHIP_DRAG*DELTA_TIME

        __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4714, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4714, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_10 = PyNumber_Multiply(__pyx_t_2, __pyx_t_21); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4714, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_XDECREF_SET(__pyx_v_drag_amount, __pyx_t_10);
        __pyx_t_10 = 0;

+4715:                     if drag_amount > abs(bullet_sim_ship_state.speed):

        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4715, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_21 = __Pyx_PyNumber_Absolute(__pyx_t_10); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4715, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = PyObject_RichCompare(__pyx_v_drag_amount, __pyx_t_21, Py_GT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4715, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4715, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (__pyx_t_14) {
/* … */
          goto __pyx_L92;
        }

+4716:                         bullet_sim_ship_state.speed = 0.0

          if (__Pyx_PyObject_SetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 4716, __pyx_L1_error)

 4717:                     else:

+4718:                         bullet_sim_ship_state.speed -= drag_amount*sign(bullet_sim_ship_state.speed)

        /*else*/ {
          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4718, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_2 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4718, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4718, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_11 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_9))) {
            __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9);
            assert(__pyx_t_2);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
            __Pyx_INCREF(__pyx_t_2);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
            __pyx_t_11 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_7};
            __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4718, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_21);
          }
          __pyx_t_9 = PyNumber_Multiply(__pyx_v_drag_amount, __pyx_t_21); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4718, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __pyx_t_21 = PyNumber_InPlaceSubtract(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4718, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (__Pyx_PyObject_SetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed, __pyx_t_21) < 0) __PYX_ERR(0, 4718, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        }
        __pyx_L92:;

+4719:                     if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

        __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4719, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        if (__pyx_t_14) {
/* … */
        }

+4720:                         assert -SHIP_MAX_THRUST <= thrust <= SHIP_MAX_THRUST  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4720, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_21);
            __pyx_t_9 = PyNumber_Negative(__pyx_t_21); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4720, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
            __pyx_t_21 = PyObject_RichCompare(__pyx_t_9, __pyx_v_thrust, Py_LE); __Pyx_XGOTREF(__pyx_t_21); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4720, __pyx_L1_error)
            if (__Pyx_PyObject_IsTrue(__pyx_t_21)) {
              __Pyx_DECREF(__pyx_t_21);
              __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4720, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_10);
              __pyx_t_21 = PyObject_RichCompare(__pyx_v_thrust, __pyx_t_10, Py_LE); __Pyx_XGOTREF(__pyx_t_21); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4720, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            }
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4720, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
            if (unlikely(!__pyx_t_14)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 4720, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 4720, __pyx_L1_error)
          #endif

 4721:                     # thrust = min(max(-SHIP_MAX_THRUST, thrust), SHIP_MAX_THRUST)

 4722:                     # Apply thrust

 4723:                     # print(bullet_sim_ship_state.speed)

+4724:                     bullet_sim_ship_state.speed += thrust*DELTA_TIME

        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4724, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4724, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_10 = PyNumber_Multiply(__pyx_v_thrust, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4724, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_t_21, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4724, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed, __pyx_t_9) < 0) __PYX_ERR(0, 4724, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 4725:                     # if ENABLE_ASSERTIONS:

 4726:                     #    assert -SHIP_MAX_SPEED <= bullet_sim_ship_state.speed <= SHIP_MAX_SPEED, f"In bullet sim, ship speed OoB: {bullet_sim_ship_state.speed}"

 4727:                     # bullet_sim_ship_state.speed = min(max(-SHIP_MAX_SPEED, bullet_sim_ship_state.speed), SHIP_MAX_SPEED)

+4728:                     if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4728, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4728, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (__pyx_t_14) {
/* … */
        }

+4729:                         assert -SHIP_MAX_TURN_RATE <= turn_rate <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4729, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_10 = PyNumber_Negative(__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4729, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_9 = PyObject_RichCompare(__pyx_t_10, __pyx_v_turn_rate, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4729, __pyx_L1_error)
            if (__Pyx_PyObject_IsTrue(__pyx_t_9)) {
              __Pyx_DECREF(__pyx_t_9);
              __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4729, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_21);
              __pyx_t_9 = PyObject_RichCompare(__pyx_v_turn_rate, __pyx_t_21, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4729, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
            }
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4729, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (unlikely(!__pyx_t_14)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 4729, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 4729, __pyx_L1_error)
          #endif

 4730:                     # turn_rate = min(max(-SHIP_MAX_TURN_RATE, turn_rate), SHIP_MAX_TURN_RATE)

 4731:                     # Update the angle based on turning rate

+4732:                     bullet_sim_ship_state.heading += turn_rate*DELTA_TIME

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4732, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4732, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_21 = PyNumber_Multiply(__pyx_v_turn_rate, __pyx_t_10); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4732, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = PyNumber_InPlaceAdd(__pyx_t_9, __pyx_t_21); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4732, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_heading, __pyx_t_10) < 0) __PYX_ERR(0, 4732, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 4733:                     # Keep the angle within (0, 360)

+4734:                     bullet_sim_ship_state.heading %= 360.0

        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4734, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_21 = __Pyx_PyFloat_RemainderObjC(__pyx_t_10, __pyx_mstate_global->__pyx_float_360_0, 360.0, 1, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4734, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_heading, __pyx_t_21) < 0) __PYX_ERR(0, 4734, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

 4735:                     # Use speed magnitude to get velocity vector

+4736:                     rad_heading = radians(bullet_sim_ship_state.heading)

        __pyx_t_10 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4736, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4736, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_11 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_9))) {
          __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
          assert(__pyx_t_10);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
          __Pyx_INCREF(__pyx_t_10);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
          __pyx_t_11 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_7};
          __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4736, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
        }
        __Pyx_XDECREF_SET(__pyx_v_rad_heading, __pyx_t_21);
        __pyx_t_21 = 0;

+4737:                     bullet_sim_ship_state.velocity = (cos(rad_heading)*bullet_sim_ship_state.speed, sin(rad_heading)*bullet_sim_ship_state.speed)

        __pyx_t_24 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_24 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4737, __pyx_L1_error)
        __pyx_t_21 = PyFloat_FromDouble(cos(__pyx_t_24)); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_7 = PyNumber_Multiply(__pyx_t_21, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_24 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_24 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4737, __pyx_L1_error)
        __pyx_t_9 = PyFloat_FromDouble(sin(__pyx_t_24)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_10 = PyNumber_Multiply(__pyx_t_9, __pyx_t_21); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = PyTuple_New(2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_GIVEREF(__pyx_t_7);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 4737, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_10);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 4737, __pyx_L1_error);
        __pyx_t_7 = 0;
        __pyx_t_10 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_21) < 0) __PYX_ERR(0, 4737, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

 4738:                     # Update the position based off the velocities

 4739:                     # Do the wrap in the same operation

+4740:                     bullet_sim_ship_state.position = ((bullet_sim_ship_state.position[0] + bullet_sim_ship_state.velocity[0]*DELTA_TIME) % self.game_state.map_size[0], (bullet_sim_ship_state.position[1] + bullet_sim_ship_state.velocity[1]*DELTA_TIME) % self.game_state.map_size[1])

        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_21, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_21, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __pyx_t_9 = PyNumber_Multiply(__pyx_t_7, __pyx_t_21); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = PyNumber_Add(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = PyNumber_Remainder(__pyx_t_21, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_2 = PyNumber_Multiply(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_Add(__pyx_t_21, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_21, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __pyx_t_21 = PyNumber_Remainder(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_GIVEREF(__pyx_t_10);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_10) != (0)) __PYX_ERR(0, 4740, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_21);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_21) != (0)) __PYX_ERR(0, 4740, __pyx_L1_error);
        __pyx_t_10 = 0;
        __pyx_t_21 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_position, __pyx_t_2) < 0) __PYX_ERR(0, 4740, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 4741: 

 4742:             # Check bullet/asteroid collisions

+4743:             bullet_remove_idxs = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_bullet_remove_idxs, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

 4744:             #asteroid_remove_idxs: set[int] = set()

+4745:             len_bullets = len(bullets)

    if (unlikely(__pyx_v_bullets == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
      __PYX_ERR(0, 4745, __pyx_L1_error)
    }
    __pyx_t_15 = __Pyx_PyList_GET_SIZE(__pyx_v_bullets); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4745, __pyx_L1_error)
    __pyx_v_len_bullets = __pyx_t_15;

+4746:             for b_idx, b in enumerate(chain(bullets, [my_bullet] if my_bullet is not None else [])):

    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
    __pyx_t_10 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4746, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_14 = (((PyObject *)__pyx_v_my_bullet) != Py_None);
    if (__pyx_t_14) {
      __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4746, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_INCREF((PyObject *)__pyx_v_my_bullet);
      __Pyx_GIVEREF((PyObject *)__pyx_v_my_bullet);
      if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, ((PyObject *)__pyx_v_my_bullet)) != (0)) __PYX_ERR(0, 4746, __pyx_L1_error);
      __pyx_t_7 = __pyx_t_6;
      __pyx_t_6 = 0;
    } else {
      __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4746, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_7 = __pyx_t_6;
      __pyx_t_6 = 0;
    }
    __pyx_t_11 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_10);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_11 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_v_bullets, __pyx_t_7};
      __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4746, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
    }
    if (likely(PyList_CheckExact(__pyx_t_21)) || PyTuple_CheckExact(__pyx_t_21)) {
      __pyx_t_9 = __pyx_t_21; __Pyx_INCREF(__pyx_t_9);
      __pyx_t_15 = 0;
      __pyx_t_12 = NULL;
    } else {
      __pyx_t_15 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_21); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4746, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4746, __pyx_L1_error)
    }
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    for (;;) {
      if (likely(!__pyx_t_12)) {
        if (likely(PyList_CheckExact(__pyx_t_9))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4746, __pyx_L1_error)
            #endif
            if (__pyx_t_15 >= __pyx_temp) break;
          }
          __pyx_t_21 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_15);
          ++__pyx_t_15;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4746, __pyx_L1_error)
            #endif
            if (__pyx_t_15 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_21 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_15));
          #else
          __pyx_t_21 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_15);
          #endif
          ++__pyx_t_15;
        }
        if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4746, __pyx_L1_error)
      } else {
        __pyx_t_21 = __pyx_t_12(__pyx_t_9);
        if (unlikely(!__pyx_t_21)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4746, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_21);
      __pyx_t_21 = 0;
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_v_b_idx, __pyx_t_2);
      __pyx_t_21 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4746, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_2);
      __pyx_t_2 = __pyx_t_21;
      __pyx_t_21 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+4747:                 b_tail = (b.position[0] + b.tail_delta[0], b.position[1] + b.tail_delta[1])

      __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_21, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_tail_delta); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_21, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_21 = PyNumber_Add(__pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_tail_delta); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = PyNumber_Add(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GIVEREF(__pyx_t_21);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_21) != (0)) __PYX_ERR(0, 4747, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_10);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 4747, __pyx_L1_error);
      __pyx_t_21 = 0;
      __pyx_t_10 = 0;
      __Pyx_XDECREF_SET(__pyx_v_b_tail, ((PyObject*)__pyx_t_6));
      __pyx_t_6 = 0;

+4748:                 for a_idx, a in enumerate(asteroids):

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_6 = __pyx_mstate_global->__pyx_int_0;
      if (likely(PyList_CheckExact(__pyx_v_asteroids)) || PyTuple_CheckExact(__pyx_v_asteroids)) {
        __pyx_t_10 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_10);
        __pyx_t_8 = 0;
        __pyx_t_25 = NULL;
      } else {
        __pyx_t_8 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_v_asteroids); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4748, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 4748, __pyx_L1_error)
      }
      for (;;) {
        if (likely(!__pyx_t_25)) {
          if (likely(PyList_CheckExact(__pyx_t_10))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4748, __pyx_L1_error)
              #endif
              if (__pyx_t_8 >= __pyx_temp) break;
            }
            __pyx_t_21 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_8);
            ++__pyx_t_8;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4748, __pyx_L1_error)
              #endif
              if (__pyx_t_8 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_21 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_8));
            #else
            __pyx_t_21 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_8);
            #endif
            ++__pyx_t_8;
          }
          if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4748, __pyx_L1_error)
        } else {
          __pyx_t_21 = __pyx_t_25(__pyx_t_10);
          if (unlikely(!__pyx_t_21)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4748, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_21);
        __pyx_t_21 = 0;
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_XDECREF_SET(__pyx_v_a_idx, __pyx_t_6);
        __pyx_t_21 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4748, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_6);
        __pyx_t_6 = __pyx_t_21;
        __pyx_t_21 = 0;
/* … */
        __pyx_L97_continue:;
      }
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      goto __pyx_L103_for_end;
      __pyx_L98_break:;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      goto __pyx_L103_for_end;
      __pyx_L103_for_end:;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+4749:                     if a_idx in asteroid_remove_idxs:

        __pyx_t_14 = (__Pyx_PySet_ContainsTF(__pyx_v_a_idx, __pyx_v_asteroid_remove_idxs, Py_EQ)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4749, __pyx_L1_error)
        if (__pyx_t_14) {
/* … */
        }

+4750:                         continue

          goto __pyx_L97_continue;

 4751:                     # If collision occurs

+4752:                     if asteroid_bullet_collision(b.position, b_tail, a.position, a.radius):

        __pyx_t_7 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_asteroid_bullet_collision); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4752, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4752, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4752, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4752, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_11 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_19))) {
          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_19);
          assert(__pyx_t_7);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19);
          __Pyx_INCREF(__pyx_t_7);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_19, __pyx__function);
          __pyx_t_11 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_7, __pyx_t_4, __pyx_v_b_tail, __pyx_t_5, __pyx_t_3};
          __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_11, (5-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4752, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
        }
        __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4752, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        if (__pyx_t_14) {
/* … */
        }

+4753:                         if b_idx == len_bullets:

          __pyx_t_21 = PyLong_FromSsize_t(__pyx_v_len_bullets); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4753, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_19 = PyObject_RichCompare(__pyx_v_b_idx, __pyx_t_21, Py_EQ); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4753, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4753, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          if (__pyx_t_14) {
/* … */
          }

 4754:                             # This bullet is my bullet!

 4755:                             #bullet_sim_time += time.perf_counter() - start_time

+4756:                             return a, timesteps_until_bullet_hit_asteroid, ship_not_collided_with_asteroid

            __Pyx_XDECREF(__pyx_r);
            __pyx_t_19 = __Pyx_PyBool_FromLong(__pyx_v_ship_not_collided_with_asteroid); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4756, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_19);
            __pyx_t_21 = PyTuple_New(3); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4756, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_21);
            __Pyx_INCREF(__pyx_v_a);
            __Pyx_GIVEREF(__pyx_v_a);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_v_a) != (0)) __PYX_ERR(0, 4756, __pyx_L1_error);
            __Pyx_INCREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
            __Pyx_GIVEREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 1, __pyx_v_timesteps_until_bullet_hit_asteroid) != (0)) __PYX_ERR(0, 4756, __pyx_L1_error);
            __Pyx_GIVEREF(__pyx_t_19);
            if (__Pyx_PyTuple_SET_ITEM(__pyx_t_21, 2, __pyx_t_19) != (0)) __PYX_ERR(0, 4756, __pyx_L1_error);
            __pyx_t_19 = 0;
            __pyx_r = ((PyObject*)__pyx_t_21);
            __pyx_t_21 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            goto __pyx_L0;

 4757:                         else:

 4758:                             # Mark bullet for removal

+4759:                             bullet_remove_idxs.append(b_idx)

          /*else*/ {
            __pyx_t_23 = __Pyx_PyList_Append(__pyx_v_bullet_remove_idxs, __pyx_v_b_idx); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4759, __pyx_L1_error)

 4760:                             # Create asteroid splits and mark it for removal

+4761:                             if a.size != 1:

            __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4761, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_21);
            __pyx_t_14 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_21, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4761, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
            if (__pyx_t_14) {
/* … */
            }

+4762:                                 asteroids.extend(forecast_instantaneous_asteroid_bullet_splits_from_velocity(a, b.velocity, self.game_state))

              __pyx_t_19 = __pyx_v_asteroids;
              __Pyx_INCREF(__pyx_t_19);
              __pyx_t_5 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_forecast_instantaneous_asteroid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4762, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_4);
              __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4762, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_7);
              __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 4762, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_20);
              __pyx_t_11 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_4))) {
                __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
                assert(__pyx_t_5);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
                __Pyx_INCREF(__pyx_t_5);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
                __pyx_t_11 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_v_a, __pyx_t_7, __pyx_t_20};
                __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
                __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
                __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
                __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4762, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_3);
              }
              __pyx_t_11 = 0;
              {
                PyObject *__pyx_callargs[2] = {__pyx_t_19, __pyx_t_3};
                __pyx_t_21 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
                if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4762, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_21);
              }
              __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+4763:                             asteroid_remove_idxs.add(a_idx)

            __pyx_t_23 = PySet_Add(__pyx_v_asteroid_remove_idxs, __pyx_v_a_idx); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4763, __pyx_L1_error)

 4764:                             # Stop checking this bullet

+4765:                             break

            goto __pyx_L98_break;
          }

 4766:             # Remove bullets

+4767:             if bullet_remove_idxs:

    __pyx_t_14 = (__Pyx_PyList_GET_SIZE(__pyx_v_bullet_remove_idxs) != 0);
    if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_14 < 0))) __PYX_ERR(0, 4767, __pyx_L1_error)
    if (__pyx_t_14) {
/* … */
    }

+4768:                 bullets = [bullet for idx, bullet in enumerate(bullets) if idx not in bullet_remove_idxs]

      { /* enter inner scope */
        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4768, __pyx_L108_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_15 = 0;
        __pyx_t_9 = __pyx_v_bullets; __Pyx_INCREF(__pyx_t_9);
        __pyx_t_8 = 0;
        for (;;) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4768, __pyx_L108_error)
            #endif
            if (__pyx_t_8 >= __pyx_temp) break;
          }
          __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_8);
          ++__pyx_t_8;
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4768, __pyx_L108_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_XDECREF_SET(__pyx_9genexpr42__pyx_v_bullet, __pyx_t_6);
          __pyx_t_6 = 0;
          __pyx_9genexpr42__pyx_v_idx = __pyx_t_15;
          __pyx_t_15 = (__pyx_t_15 + 1);
          __pyx_t_6 = PyLong_FromSsize_t(__pyx_9genexpr42__pyx_v_idx); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4768, __pyx_L108_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_14 = (__Pyx_PySequence_ContainsTF(__pyx_t_6, __pyx_v_bullet_remove_idxs, Py_NE)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4768, __pyx_L108_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (__pyx_t_14) {
            if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_9genexpr42__pyx_v_bullet))) __PYX_ERR(0, 4768, __pyx_L108_error)
          }
        }
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_XDECREF(__pyx_9genexpr42__pyx_v_bullet); __pyx_9genexpr42__pyx_v_bullet = 0;
        goto __pyx_L113_exit_scope;
        __pyx_L108_error:;
        __Pyx_XDECREF(__pyx_9genexpr42__pyx_v_bullet); __pyx_9genexpr42__pyx_v_bullet = 0;
        goto __pyx_L1_error;
        __pyx_L113_exit_scope:;
      } /* exit inner scope */
      __Pyx_DECREF_SET(__pyx_v_bullets, ((PyObject*)__pyx_t_2));
      __pyx_t_2 = 0;

 4769: 

 4770:             # Check mine/asteroid collisions

+4771:             mine_remove_idxs: list[int] = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4771, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_mine_remove_idxs, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+4772:             new_asteroids: list[Asteroid] = []

    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4772, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_new_asteroids, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+4773:             for m_idx, mine in enumerate(mines):

    __pyx_t_15 = 0;
    __pyx_t_2 = __pyx_v_mines; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_8 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4773, __pyx_L1_error)
        #endif
        if (__pyx_t_8 >= __pyx_temp) break;
      }
      __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_8);
      ++__pyx_t_8;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4773, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_XDECREF_SET(__pyx_v_mine, __pyx_t_9);
      __pyx_t_9 = 0;
      __pyx_v_m_idx = __pyx_t_15;
      __pyx_t_15 = (__pyx_t_15 + 1);
/* … */
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+4774:                 if mine.remaining_time < EPS:

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4774, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_6 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4774, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = PyObject_RichCompare(__pyx_t_9, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4774, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4774, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (__pyx_t_14) {
/* … */
      }

 4775:                     # Mine is detonating

+4776:                     mine_remove_idxs.append(m_idx)

        __pyx_t_10 = PyLong_FromSsize_t(__pyx_v_m_idx); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4776, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_23 = __Pyx_PyList_Append(__pyx_v_mine_remove_idxs, __pyx_t_10); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4776, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+4777:                     for a_idx, asteroid in enumerate(asteroids):

        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __pyx_t_10 = __pyx_mstate_global->__pyx_int_0;
        if (likely(PyList_CheckExact(__pyx_v_asteroids)) || PyTuple_CheckExact(__pyx_v_asteroids)) {
          __pyx_t_6 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_6);
          __pyx_t_18 = 0;
          __pyx_t_12 = NULL;
        } else {
          __pyx_t_18 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_v_asteroids); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4777, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4777, __pyx_L1_error)
        }
        for (;;) {
          if (likely(!__pyx_t_12)) {
            if (likely(PyList_CheckExact(__pyx_t_6))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4777, __pyx_L1_error)
                #endif
                if (__pyx_t_18 >= __pyx_temp) break;
              }
              __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_18);
              ++__pyx_t_18;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4777, __pyx_L1_error)
                #endif
                if (__pyx_t_18 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_18));
              #else
              __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_18);
              #endif
              ++__pyx_t_18;
            }
            if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4777, __pyx_L1_error)
          } else {
            __pyx_t_9 = __pyx_t_12(__pyx_t_6);
            if (unlikely(!__pyx_t_9)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4777, __pyx_L1_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_9);
          __pyx_t_9 = 0;
          __Pyx_INCREF(__pyx_t_10);
          __Pyx_XDECREF_SET(__pyx_v_a_idx, __pyx_t_10);
          __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4777, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_10);
          __pyx_t_10 = __pyx_t_9;
          __pyx_t_9 = 0;
/* … */
          __pyx_L117_continue:;
        }
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+4778:                         if a_idx in asteroid_remove_idxs:

          __pyx_t_14 = (__Pyx_PySet_ContainsTF(__pyx_v_a_idx, __pyx_v_asteroid_remove_idxs, Py_EQ)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4778, __pyx_L1_error)
          if (__pyx_t_14) {
/* … */
          }

+4779:                             continue

            goto __pyx_L117_continue;

 4780:                         #if check_collision(asteroid.position[0], asteroid.position[1], asteroid.radius, mine.position[0], mine.position[1], MINE_BLAST_RADIUS):

+4781:                         delta_x = asteroid.position[0] - mine.position[0]

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4781, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4781, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4781, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4781, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = PyNumber_Subtract(__pyx_t_21, __pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4781, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_9);
          __pyx_t_9 = 0;

+4782:                         delta_y = asteroid.position[1] - mine.position[1]

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4782, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4782, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4782, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_21 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4782, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = PyNumber_Subtract(__pyx_t_3, __pyx_t_21); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4782, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_9);
          __pyx_t_9 = 0;

+4783:                         separation = asteroid.radius + MINE_BLAST_RADIUS

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4783, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4783, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_3 = PyNumber_Add(__pyx_t_9, __pyx_t_21); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4783, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_3);
          __pyx_t_3 = 0;

+4784:                         if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

          __pyx_t_3 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_21 = PyObject_RichCompare(__pyx_t_3, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_21); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          if (__pyx_t_1) {
          } else {
            __pyx_t_14 = __pyx_t_1;
            goto __pyx_L121_bool_binop_done;
          }
          __pyx_t_21 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_3 = PyObject_RichCompare(__pyx_t_21, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (__pyx_t_1) {
          } else {
            __pyx_t_14 = __pyx_t_1;
            goto __pyx_L121_bool_binop_done;
          }
          __pyx_t_3 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_21 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_9 = PyNumber_Add(__pyx_t_3, __pyx_t_21); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __pyx_t_21 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_3 = PyObject_RichCompare(__pyx_t_9, __pyx_t_21, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4784, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_14 = __pyx_t_1;
          __pyx_L121_bool_binop_done:;
          if (__pyx_t_14) {
/* … */
          }

+4785:                             if asteroid.size != 1:

            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4785, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_14 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4785, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            if (__pyx_t_14) {
/* … */
            }

+4786:                                 new_asteroids.extend(forecast_asteroid_mine_instantaneous_splits(asteroid, mine, self.game_state))

              __pyx_t_21 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_mine_instantan); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4786, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
              __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4786, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_19);
              __pyx_t_11 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_9))) {
                __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_9);
                assert(__pyx_t_21);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
                __Pyx_INCREF(__pyx_t_21);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
                __pyx_t_11 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[4] = {__pyx_t_21, __pyx_v_asteroid, __pyx_v_mine, __pyx_t_19};
                __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
                __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4786, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_3);
              }
              __pyx_t_23 = __Pyx_PyList_Extend(__pyx_v_new_asteroids, __pyx_t_3); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4786, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+4787:                             asteroid_remove_idxs.add(a_idx)

            __pyx_t_23 = PySet_Add(__pyx_v_asteroid_remove_idxs, __pyx_v_a_idx); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4787, __pyx_L1_error)

+4788:             if mine_remove_idxs:

    __pyx_t_14 = (__Pyx_PyList_GET_SIZE(__pyx_v_mine_remove_idxs) != 0);
    if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_14 < 0))) __PYX_ERR(0, 4788, __pyx_L1_error)
    if (__pyx_t_14) {
/* … */
    }

+4789:                 mines = [mine for idx, mine in enumerate(mines) if idx not in mine_remove_idxs]

      { /* enter inner scope */
        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4789, __pyx_L130_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_15 = 0;
        __pyx_t_10 = __pyx_v_mines; __Pyx_INCREF(__pyx_t_10);
        __pyx_t_8 = 0;
        for (;;) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4789, __pyx_L130_error)
            #endif
            if (__pyx_t_8 >= __pyx_temp) break;
          }
          __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_8);
          ++__pyx_t_8;
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4789, __pyx_L130_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_XDECREF_SET(__pyx_9genexpr43__pyx_v_mine, __pyx_t_6);
          __pyx_t_6 = 0;
          __pyx_9genexpr43__pyx_v_idx = __pyx_t_15;
          __pyx_t_15 = (__pyx_t_15 + 1);
          __pyx_t_6 = PyLong_FromSsize_t(__pyx_9genexpr43__pyx_v_idx); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4789, __pyx_L130_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_14 = (__Pyx_PySequence_ContainsTF(__pyx_t_6, __pyx_v_mine_remove_idxs, Py_NE)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4789, __pyx_L130_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (__pyx_t_14) {
            if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_9genexpr43__pyx_v_mine))) __PYX_ERR(0, 4789, __pyx_L130_error)
          }
        }
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_XDECREF(__pyx_9genexpr43__pyx_v_mine); __pyx_9genexpr43__pyx_v_mine = 0;
        goto __pyx_L135_exit_scope;
        __pyx_L130_error:;
        __Pyx_XDECREF(__pyx_9genexpr43__pyx_v_mine); __pyx_9genexpr43__pyx_v_mine = 0;
        goto __pyx_L1_error;
        __pyx_L135_exit_scope:;
      } /* exit inner scope */
      __Pyx_DECREF_SET(__pyx_v_mines, ((PyObject*)__pyx_t_2));
      __pyx_t_2 = 0;

+4790:             asteroids.extend(new_asteroids)

    __pyx_t_10 = __pyx_v_asteroids;
    __Pyx_INCREF(__pyx_t_10);
    __pyx_t_11 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_v_new_asteroids};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4790, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 4791: 

 4792:             # Check ship/asteroid collisions

+4793:             if ship_not_collided_with_asteroid:

    if (__pyx_v_ship_not_collided_with_asteroid) {
/* … */
    }

+4794:                 if whole_move_sequence is not None:

      __pyx_t_14 = (__pyx_v_whole_move_sequence != ((PyObject*)Py_None));
      if (__pyx_t_14) {
/* … */
        goto __pyx_L137;
      }

+4795:                     assert bullet_sim_ship_state is not None

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_14 = (__pyx_v_bullet_sim_ship_state != Py_None);
          if (unlikely(!__pyx_t_14)) {
            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
            __PYX_ERR(0, 4795, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 4795, __pyx_L1_error)
        #endif

+4796:                     ship_position = bullet_sim_ship_state.position

        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_bullet_sim_ship_state, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4796, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_XDECREF_SET(__pyx_v_ship_position, __pyx_t_2);
        __pyx_t_2 = 0;

+4797:                 elif ship_state is not None:

      __pyx_t_14 = (((PyObject *)__pyx_v_ship_state) != Py_None);
      if (__pyx_t_14) {
/* … */
        goto __pyx_L137;
      }

+4798:                     ship_position = ship_state.position

        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4798, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_XDECREF_SET(__pyx_v_ship_position, __pyx_t_2);
        __pyx_t_2 = 0;

 4799:                 else:

+4800:                     ship_position = self.ship_state.position

      /*else*/ {
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4800, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4800, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_position, __pyx_t_10);
        __pyx_t_10 = 0;
      }
      __pyx_L137:;

+4801:                 for a_idx, asteroid in enumerate(asteroids):

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_10 = __pyx_mstate_global->__pyx_int_0;
      if (likely(PyList_CheckExact(__pyx_v_asteroids)) || PyTuple_CheckExact(__pyx_v_asteroids)) {
        __pyx_t_2 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_2);
        __pyx_t_15 = 0;
        __pyx_t_12 = NULL;
      } else {
        __pyx_t_15 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_asteroids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4801, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4801, __pyx_L1_error)
      }
      for (;;) {
        if (likely(!__pyx_t_12)) {
          if (likely(PyList_CheckExact(__pyx_t_2))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4801, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_15);
            ++__pyx_t_15;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4801, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_6 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_15));
            #else
            __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_15);
            #endif
            ++__pyx_t_15;
          }
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4801, __pyx_L1_error)
        } else {
          __pyx_t_6 = __pyx_t_12(__pyx_t_2);
          if (unlikely(!__pyx_t_6)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4801, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_6);
        __pyx_t_6 = 0;
        __Pyx_INCREF(__pyx_t_10);
        __Pyx_XDECREF_SET(__pyx_v_a_idx, __pyx_t_10);
        __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4801, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_10);
        __pyx_t_10 = __pyx_t_6;
        __pyx_t_6 = 0;
/* … */
        __pyx_L138_continue:;
      }
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      goto __pyx_L146_for_end;
      __pyx_L139_break:;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      goto __pyx_L146_for_end;
      __pyx_L146_for_end:;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+4802:                     if a_idx in asteroid_remove_idxs:

        __pyx_t_14 = (__Pyx_PySet_ContainsTF(__pyx_v_a_idx, __pyx_v_asteroid_remove_idxs, Py_EQ)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4802, __pyx_L1_error)
        if (__pyx_t_14) {
/* … */
        }

+4803:                         continue

          goto __pyx_L138_continue;

 4804:                     #if check_collision(ship_position[0], ship_position[1], SHIP_RADIUS, asteroid.position[0], asteroid.position[1], asteroid.radius):

+4805:                     delta_x = ship_position[0] - asteroid.position[0]

        __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ship_position, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4805, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4805, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4805, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyNumber_Subtract(__pyx_t_6, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4805, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_3);
        __pyx_t_3 = 0;

+4806:                     delta_y = ship_position[1] - asteroid.position[1]

        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_ship_position, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4806, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4806, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4806, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_Subtract(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4806, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_9);
        __pyx_t_9 = 0;

+4807:                     separation = SHIP_RADIUS + asteroid.radius

        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4807, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4807, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = PyNumber_Add(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4807, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_3);
        __pyx_t_3 = 0;

+4808:                     if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

        __pyx_t_3 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_6 = PyObject_RichCompare(__pyx_t_3, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (__pyx_t_1) {
        } else {
          __pyx_t_14 = __pyx_t_1;
          goto __pyx_L142_bool_binop_done;
        }
        __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_6, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (__pyx_t_1) {
        } else {
          __pyx_t_14 = __pyx_t_1;
          goto __pyx_L142_bool_binop_done;
        }
        __pyx_t_3 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_6 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_9 = PyNumber_Add(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_6 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_9, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4808, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_14 = __pyx_t_1;
        __pyx_L142_bool_binop_done:;
        if (__pyx_t_14) {
/* … */
        }

 4809:                         # Note that we assume the ship is stationary. In reality, we don't know how the ship will move during the bullet sim. Therefore, these forecasted asteroids may not be accurate if the ship moves.

+4810:                         if asteroid.size != 1:

          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4810, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_14 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4810, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (__pyx_t_14) {
/* … */
          }

+4811:                             asteroids.extend(forecast_asteroid_ship_splits(asteroid, 0, (0.0, 0.0), self.game_state))

            __pyx_t_6 = __pyx_v_asteroids;
            __Pyx_INCREF(__pyx_t_6);
            __pyx_t_19 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_ship_splits); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4811, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_21);
            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4811, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_t_11 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_21))) {
              __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_21);
              assert(__pyx_t_19);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21);
              __Pyx_INCREF(__pyx_t_19);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_21, __pyx__function);
              __pyx_t_11 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[5] = {__pyx_t_19, __pyx_v_asteroid, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_tuple[0], __pyx_t_4};
              __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_11, (5-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
              if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4811, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
            }
            __pyx_t_11 = 0;
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9};
              __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4811, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_3);
            }
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+4812:                         asteroid_remove_idxs.add(a_idx)

          __pyx_t_23 = PySet_Add(__pyx_v_asteroid_remove_idxs, __pyx_v_a_idx); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4812, __pyx_L1_error)

 4813:                         # Stop checking this ship's collisions. And also return saying the ship took damage!

 4814:                         #print('ship ast coll!')

+4815:                         ship_not_collided_with_asteroid = False

          __pyx_v_ship_not_collided_with_asteroid = 0;

+4816:                         break

          goto __pyx_L139_break;

 4817:             # Cull asteroids marked for removal

+4818:             if len(asteroid_remove_idxs) > 2:

    __pyx_t_15 = __Pyx_PySet_GET_SIZE(__pyx_v_asteroid_remove_idxs); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 4818, __pyx_L1_error)
    __pyx_t_14 = (__pyx_t_15 > 2);
    if (__pyx_t_14) {
/* … */
    }
  }

+4819:                 asteroids = [asteroid for idx, asteroid in enumerate(asteroids) if idx not in asteroid_remove_idxs]

      { /* enter inner scope */
        __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4819, __pyx_L150_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
        if (likely(PyList_CheckExact(__pyx_v_asteroids)) || PyTuple_CheckExact(__pyx_v_asteroids)) {
          __pyx_t_3 = __pyx_v_asteroids; __Pyx_INCREF(__pyx_t_3);
          __pyx_t_15 = 0;
          __pyx_t_12 = NULL;
        } else {
          __pyx_t_15 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_asteroids); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4819, __pyx_L150_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4819, __pyx_L150_error)
        }
        for (;;) {
          if (likely(!__pyx_t_12)) {
            if (likely(PyList_CheckExact(__pyx_t_3))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4819, __pyx_L150_error)
                #endif
                if (__pyx_t_15 >= __pyx_temp) break;
              }
              __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_15);
              ++__pyx_t_15;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4819, __pyx_L150_error)
                #endif
                if (__pyx_t_15 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_15));
              #else
              __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_15);
              #endif
              ++__pyx_t_15;
            }
            if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4819, __pyx_L150_error)
          } else {
            __pyx_t_9 = __pyx_t_12(__pyx_t_3);
            if (unlikely(!__pyx_t_9)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4819, __pyx_L150_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_XDECREF_SET(__pyx_9genexpr44__pyx_v_asteroid, __pyx_t_9);
          __pyx_t_9 = 0;
          __Pyx_INCREF(__pyx_t_2);
          __Pyx_XDECREF_SET(__pyx_9genexpr44__pyx_v_idx, __pyx_t_2);
          __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4819, __pyx_L150_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_2);
          __pyx_t_2 = __pyx_t_9;
          __pyx_t_9 = 0;
          __pyx_t_14 = (__Pyx_PySet_ContainsTF(__pyx_9genexpr44__pyx_v_idx, __pyx_v_asteroid_remove_idxs, Py_NE)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 4819, __pyx_L150_error)
          if (__pyx_t_14) {
            if (unlikely(__Pyx_ListComp_Append(__pyx_t_10, (PyObject*)__pyx_9genexpr44__pyx_v_asteroid))) __PYX_ERR(0, 4819, __pyx_L150_error)
          }
        }
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF(__pyx_9genexpr44__pyx_v_asteroid); __pyx_9genexpr44__pyx_v_asteroid = 0;
        __Pyx_XDECREF(__pyx_9genexpr44__pyx_v_idx); __pyx_9genexpr44__pyx_v_idx = 0;
        goto __pyx_L155_exit_scope;
        __pyx_L150_error:;
        __Pyx_XDECREF(__pyx_9genexpr44__pyx_v_asteroid); __pyx_9genexpr44__pyx_v_asteroid = 0;
        __Pyx_XDECREF(__pyx_9genexpr44__pyx_v_idx); __pyx_9genexpr44__pyx_v_idx = 0;
        goto __pyx_L1_error;
        __pyx_L155_exit_scope:;
      } /* exit inner scope */
      __Pyx_DECREF_SET(__pyx_v_asteroids, __pyx_t_10);
      __pyx_t_10 = 0;

+4820:                 asteroid_remove_idxs.clear()

      __pyx_t_23 = PySet_Clear(__pyx_v_asteroid_remove_idxs); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(0, 4820, __pyx_L1_error)

 4821: 

+4822:     def apply_move_sequence(self, move_sequence: list[Action], allow_free_firing: bool = False, allow_free_mining: bool = False) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_51apply_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_51apply_move_sequence = {"apply_move_sequence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_51apply_move_sequence, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_51apply_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_move_sequence = 0;
  PyObject *__pyx_v_allow_free_firing = 0;
  PyObject *__pyx_v_allow_free_mining = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("apply_move_sequence (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_move_sequence,&__pyx_mstate_global->__pyx_n_u_allow_free_firing,&__pyx_mstate_global->__pyx_n_u_allow_free_mining,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4822, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4822, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4822, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4822, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4822, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "apply_move_sequence", 0) < 0) __PYX_ERR(0, 4822, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("apply_move_sequence", 0, 2, 4, i); __PYX_ERR(0, 4822, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4822, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4822, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4822, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4822, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_move_sequence = ((PyObject*)values[1]);
    __pyx_v_allow_free_firing = values[2];
    __pyx_v_allow_free_mining = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("apply_move_sequence", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 4822, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.apply_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_move_sequence), (&PyList_Type), 0, "move_sequence", 2))) __PYX_ERR(0, 4822, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_50apply_move_sequence(__pyx_self, __pyx_v_self, __pyx_v_move_sequence, __pyx_v_allow_free_firing, __pyx_v_allow_free_mining);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_50apply_move_sequence(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_move_sequence, PyObject *__pyx_v_allow_free_firing, PyObject *__pyx_v_allow_free_mining) {
  int __pyx_v_sim_was_safe;
  PyObject *__pyx_v_move = NULL;
  PyObject *__pyx_v_thrust = NULL;
  PyObject *__pyx_v_turn_rate = NULL;
  PyObject *__pyx_v_fire = NULL;
  PyObject *__pyx_v_drop_mine = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.Matrix.apply_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_move);
  __Pyx_XDECREF(__pyx_v_thrust);
  __Pyx_XDECREF(__pyx_v_turn_rate);
  __Pyx_XDECREF(__pyx_v_fire);
  __Pyx_XDECREF(__pyx_v_drop_mine);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4822, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_move_sequence, __pyx_mstate_global->__pyx_kp_u_list_Action) < 0) __PYX_ERR(0, 4822, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_allow_free_firing, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4822, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_allow_free_mining, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4822, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4822, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_51apply_move_sequence, 0, __pyx_mstate_global->__pyx_n_u_Matrix_apply_move_sequence, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[171])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4822, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[93]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_apply_move_sequence, __pyx_t_2) < 0) __PYX_ERR(0, 4822, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[93] = PyTuple_Pack(2, ((PyObject*)Py_False), ((PyObject*)Py_False)); if (unlikely(!__pyx_mstate_global->__pyx_tuple[93])) __PYX_ERR(0, 4822, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[93]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[93]);

 4823:         # assert isclose(self.ship_state.speed, 0.0), f"When starting in apply move sequence where the sim was safe, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}. The whole move sequence is {move_sequence}"

+4824:         sim_was_safe = True

  __pyx_v_sim_was_safe = 1;

+4825:         if not is_close(self.ship_state.speed, 0.0):  # REMOVE_FOR_COMPETITION

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_close); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4825, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4825, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4825, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_5, __pyx_mstate_global->__pyx_float_0_0};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4825, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4825, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_8 = (!__pyx_t_7);
  if (__pyx_t_8) {
/* … */
  }

+4826:             print(f"When starting in apply move sequence where the sim was safe, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}. The whole move sequence is {move_sequence}")  # REMOVE_FOR_COMPETITION

    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_builtin_print);
    __pyx_t_5 = __pyx_builtin_print; 
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_9), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_move_sequence, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_When_starting_in_apply_move_sequ;
    __pyx_t_10[1] = __pyx_t_2;
    __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_velocity_2;
    __pyx_t_10[3] = __pyx_t_4;
    __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_The_whole_move_sequence_is;
    __pyx_t_10[5] = __pyx_t_9;
    __pyx_t_11 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, 111 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
    if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4826, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_11};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4826, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+4827:         for move in move_sequence:

  __pyx_t_1 = __pyx_v_move_sequence; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_12 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4827, __pyx_L1_error)
      #endif
      if (__pyx_t_12 >= __pyx_temp) break;
    }
    __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_12);
    ++__pyx_t_12;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4827, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_move, __pyx_t_5);
    __pyx_t_5 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  goto __pyx_L7_for_end;
  __pyx_L5_break:;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  goto __pyx_L7_for_end;
  __pyx_L7_for_end:;

 4828:             #thrust = 0.0

 4829:             #turn_rate = 0.0

 4830:             #fire = False

 4831:             # drop_mine = False

 4832:             #if 'thrust' in move:

+4833:             thrust = move.thrust

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_thrust); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4833, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_thrust, __pyx_t_5);
    __pyx_t_5 = 0;

 4834:             #if 'turn_rate' in move:

+4835:             turn_rate = move.turn_rate

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_turn_rate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4835, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_XDECREF_SET(__pyx_v_turn_rate, __pyx_t_5);
    __pyx_t_5 = 0;

 4836:             #if 'fire' in move:

+4837:             fire = None if allow_free_firing else move.fire

    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_allow_free_firing); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 4837, __pyx_L1_error)
    if (__pyx_t_8) {
      __Pyx_INCREF(Py_None);
      __pyx_t_5 = Py_None;
    } else {
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_fire); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4837, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_5 = __pyx_t_11;
      __pyx_t_11 = 0;
    }
    __Pyx_XDECREF_SET(__pyx_v_fire, __pyx_t_5);
    __pyx_t_5 = 0;

 4838:             #if 'drop_mine' in move:

+4839:             drop_mine = None if allow_free_mining else move.drop_mine

    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_allow_free_mining); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 4839, __pyx_L1_error)
    if (__pyx_t_8) {
      __Pyx_INCREF(Py_None);
      __pyx_t_5 = Py_None;
    } else {
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_drop_mine); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_5 = __pyx_t_11;
      __pyx_t_11 = 0;
    }
    __Pyx_XDECREF_SET(__pyx_v_drop_mine, __pyx_t_5);
    __pyx_t_5 = 0;

 4840:             # print(f"Calling update from apply move sequence:")

+4841:             if not self.update(thrust, turn_rate, fire, drop_mine):

    __pyx_t_11 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_11);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[5] = {__pyx_t_11, __pyx_v_thrust, __pyx_v_turn_rate, __pyx_v_fire, __pyx_v_drop_mine};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 4841, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = (!__pyx_t_8);
    if (__pyx_t_7) {
/* … */
    }

+4842:                 sim_was_safe = False

      __pyx_v_sim_was_safe = 0;

+4843:                 break

      goto __pyx_L5_break;

 4844:             # print(f"After thrusting {thrust}: {self.ship_state.speed=}")

+4845:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4845, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_7) {
/* … */
  }

+4846:             assert is_close_to_zero(self.ship_state.speed), f"When returning in apply move sequence where {sim_was_safe=}, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}. The whole move sequence is {move_sequence}"  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4846, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4846, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4846, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_11))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_9};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4846, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_7)) {
        __pyx_t_1 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_sim_was_safe); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __pyx_t_11 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_9), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_5), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_move_sequence, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_When_returning_in_apply_move_seq;
        __pyx_t_13[1] = __pyx_t_1;
        __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u_the_ship_speed_is_not_zero_self;
        __pyx_t_13[3] = __pyx_t_11;
        __pyx_t_13[4] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_velocity_2;
        __pyx_t_13[5] = __pyx_t_9;
        __pyx_t_13[6] = __pyx_mstate_global->__pyx_kp_u_The_whole_move_sequence_is;
        __pyx_t_13[7] = __pyx_t_5;
        __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_13, 8, 57 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 52 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_11) + 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_11) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5));
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_3, 0, 0);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __PYX_ERR(0, 4846, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4846, __pyx_L1_error)
    #endif

+4847:         return sim_was_safe

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_sim_was_safe); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4847, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 4848: 

+4849:     def simulate_maneuver(self, move_sequence: list[Action], allow_free_firing: bool, allow_free_mining: bool) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_53simulate_maneuver(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_53simulate_maneuver = {"simulate_maneuver", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_53simulate_maneuver, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_53simulate_maneuver(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_move_sequence = 0;
  PyObject *__pyx_v_allow_free_firing = 0;
  PyObject *__pyx_v_allow_free_mining = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("simulate_maneuver (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_move_sequence,&__pyx_mstate_global->__pyx_n_u_allow_free_firing,&__pyx_mstate_global->__pyx_n_u_allow_free_mining,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4849, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4849, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4849, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4849, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4849, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "simulate_maneuver", 0) < 0) __PYX_ERR(0, 4849, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("simulate_maneuver", 1, 4, 4, i); __PYX_ERR(0, 4849, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4849, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4849, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4849, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4849, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_move_sequence = ((PyObject*)values[1]);
    __pyx_v_allow_free_firing = values[2];
    __pyx_v_allow_free_mining = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("simulate_maneuver", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 4849, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.simulate_maneuver", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_move_sequence), (&PyList_Type), 0, "move_sequence", 2))) __PYX_ERR(0, 4849, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_52simulate_maneuver(__pyx_self, __pyx_v_self, __pyx_v_move_sequence, __pyx_v_allow_free_firing, __pyx_v_allow_free_mining);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_52simulate_maneuver(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_move_sequence, PyObject *__pyx_v_allow_free_firing, PyObject *__pyx_v_allow_free_mining) {
  PyObject *__pyx_v_move = NULL;
  PyObject *__pyx_v_thrust = NULL;
  PyObject *__pyx_v_turn_rate = NULL;
  PyObject *__pyx_v_fire = NULL;
  PyObject *__pyx_v_drop_mine = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.Matrix.simulate_maneuver", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_move);
  __Pyx_XDECREF(__pyx_v_thrust);
  __Pyx_XDECREF(__pyx_v_turn_rate);
  __Pyx_XDECREF(__pyx_v_fire);
  __Pyx_XDECREF(__pyx_v_drop_mine);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_move_sequence, __pyx_mstate_global->__pyx_kp_u_list_Action) < 0) __PYX_ERR(0, 4849, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_allow_free_firing, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4849, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_allow_free_mining, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4849, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4849, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_53simulate_maneuver, 0, __pyx_mstate_global->__pyx_n_u_Matrix_simulate_maneuver, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[172])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_simulate_maneuver, __pyx_t_3) < 0) __PYX_ERR(0, 4849, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+4850:         self.intended_move_sequence = move_sequence  # Record down the intended move sequence, so if I crash and the recorded move sequence gets cut short, we still have the intended move sequence!

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_intended_move_sequence, __pyx_v_move_sequence) < 0) __PYX_ERR(0, 4850, __pyx_L1_error)

 4851:         #flag = False

 4852:         #if not is_close_to_zero(self.ship_state.speed) and self.sim_id == 333:

 4853:         #    print(f"When starting in simulate maneuver where the sim was safe, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}. The whole move sequence is REDACTED move_sequence")

 4854:             #flag = True

+4855:         for move in move_sequence:

  __pyx_t_1 = __pyx_v_move_sequence; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4855, __pyx_L1_error)
      #endif
      if (__pyx_t_2 >= __pyx_temp) break;
    }
    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
    ++__pyx_t_2;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4855, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_move, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+4856:             thrust = 0.0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __Pyx_XDECREF_SET(__pyx_v_thrust, __pyx_mstate_global->__pyx_float_0_0);

+4857:             turn_rate = 0.0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
    __Pyx_XDECREF_SET(__pyx_v_turn_rate, __pyx_mstate_global->__pyx_float_0_0);

 4858:             #if 'thrust' in move:

+4859:             thrust = move.thrust

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_thrust); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4859, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_thrust, __pyx_t_3);
    __pyx_t_3 = 0;

 4860:             #if 'turn_rate' in move:

+4861:             turn_rate = move.turn_rate

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_turn_rate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4861, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_turn_rate, __pyx_t_3);
    __pyx_t_3 = 0;

+4862:             fire = move.fire

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_fire); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4862, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_fire, __pyx_t_3);
    __pyx_t_3 = 0;

+4863:             drop_mine = move.drop_mine

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_drop_mine); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4863, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_drop_mine, __pyx_t_3);
    __pyx_t_3 = 0;

 4864:             # print(f"Calling update from sim maneuver:")

 4865:             #if self.sim_id == 23215:

 4866:                 #print(f"Calling update from sim maneuver: with {thrust=}, {turn_rate=}, {allow_firing=}")

+4867:             if not self.update(thrust, turn_rate, None if allow_free_firing else fire, None if allow_free_mining else drop_mine, move_sequence):

    __pyx_t_4 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_allow_free_firing); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4867, __pyx_L1_error)
    if (__pyx_t_6) {
      __Pyx_INCREF(Py_None);
      __pyx_t_5 = Py_None;
    } else {
      __Pyx_INCREF(__pyx_v_fire);
      __pyx_t_5 = __pyx_v_fire;
    }
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_allow_free_mining); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4867, __pyx_L1_error)
    if (__pyx_t_6) {
      __Pyx_INCREF(Py_None);
      __pyx_t_7 = Py_None;
    } else {
      __Pyx_INCREF(__pyx_v_drop_mine);
      __pyx_t_7 = __pyx_v_drop_mine;
    }
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[6] = {__pyx_t_4, __pyx_v_thrust, __pyx_v_turn_rate, __pyx_t_5, __pyx_t_7, __pyx_v_move_sequence};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (6-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4867, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 4867, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_9 = (!__pyx_t_6);
    if (__pyx_t_9) {
/* … */
    }

+4868:                 return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;

 4869:             #if flag:

 4870:             #if self.sim_id == 333:

 4871:             #    print(f"In sim {self.sim_id} After thrusting by {thrust} the true simmed ship speed is {self.ship_state.speed}")

+4872:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4872, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 4872, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_9) {
/* … */
  }

+4873:             assert is_close_to_zero(self.ship_state.speed), f"When returning in simulate maneuver where the sim was safe, the ship speed is not zero! {self.ship_state.speed=}, {self.ship_state.velocity=}. The whole move sequence is {move_sequence}"  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4873, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4873, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4873, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_8 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_8 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 4873, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_9)) {
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_7), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_7 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_move_sequence, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_When_returning_in_simulate_maneu;
        __pyx_t_10[1] = __pyx_t_1;
        __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_velocity_2;
        __pyx_t_10[3] = __pyx_t_7;
        __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_The_whole_move_sequence_is;
        __pyx_t_10[5] = __pyx_t_4;
        __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, 110 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7) + 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4));
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4873, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_3, 0, 0);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __PYX_ERR(0, 4873, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4873, __pyx_L1_error)
    #endif

+4874:         return True

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_True);
  __pyx_r = Py_True;
  goto __pyx_L0;

 4875: 

+4876:     def update(self, thrust: float = 0.0, turn_rate: float = 0.0, fire: Optional[bool] = None, drop_mine: Optional[bool] = None, whole_move_sequence: Optional[list[Action]] = None, wait_out_mines: bool = False) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_55update(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_55update = {"update", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_55update, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_55update(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  double __pyx_v_thrust;
  double __pyx_v_turn_rate;
  PyObject *__pyx_v_fire = 0;
  PyObject *__pyx_v_drop_mine = 0;
  PyObject *__pyx_v_whole_move_sequence = 0;
  PyObject *__pyx_v_wait_out_mines = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("update (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_thrust,&__pyx_mstate_global->__pyx_n_u_turn_rate,&__pyx_mstate_global->__pyx_n_u_fire,&__pyx_mstate_global->__pyx_n_u_drop_mine,&__pyx_mstate_global->__pyx_n_u_whole_move_sequence,&__pyx_mstate_global->__pyx_n_u_wait_out_mines,0};
  PyObject* values[7] = {0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4876, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "update", 0) < 0) __PYX_ERR(0, 4876, __pyx_L3_error)
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("update", 0, 1, 7, i); __PYX_ERR(0, 4876, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4876, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4876, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject*)Py_None));
      if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    if (values[1]) {
      __pyx_v_thrust = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_thrust == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4876, __pyx_L3_error)
    } else {
      __pyx_v_thrust = ((double)((double)0.0));
    }
    if (values[2]) {
      __pyx_v_turn_rate = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 4876, __pyx_L3_error)
    } else {
      __pyx_v_turn_rate = ((double)((double)0.0));
    }
    __pyx_v_fire = values[3];
    __pyx_v_drop_mine = values[4];
    __pyx_v_whole_move_sequence = ((PyObject*)values[5]);
    __pyx_v_wait_out_mines = values[6];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("update", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 4876, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.update", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_whole_move_sequence), (&PyList_Type), 1, "whole_move_sequence", 2))) __PYX_ERR(0, 4876, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_54update(__pyx_self, __pyx_v_self, __pyx_v_thrust, __pyx_v_turn_rate, __pyx_v_fire, __pyx_v_drop_mine, __pyx_v_whole_move_sequence, __pyx_v_wait_out_mines);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_54update(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, double __pyx_v_thrust, double __pyx_v_turn_rate, PyObject *__pyx_v_fire, PyObject *__pyx_v_drop_mine, PyObject *__pyx_v_whole_move_sequence, PyObject *__pyx_v_wait_out_mines) {
  PyObject *__pyx_v_return_value = NULL;
  PyObject *__pyx_v_current_set_of_moves_from_list = NULL;
  PyObject *__pyx_v_flattened_asteroids_pending_death = NULL;
  PyObject *__pyx_v_asteroid_remove_idxs = NULL;
  PyObject *__pyx_v_bullet_remove_idxs = NULL;
  PyObject *__pyx_v_b_ind = NULL;
  PyObject *__pyx_v_b = NULL;
  PyObject *__pyx_v_new_bullet_pos = NULL;
  PyObject *__pyx_v_m = NULL;
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_actual_asteroid_hit = NULL;
  PyObject *__pyx_v_timesteps_until_bullet_hit_asteroid = NULL;
  PyObject *__pyx_v_ship_was_safe = NULL;
  PyObject *__pyx_v_fire_this_timestep = NULL;
  PyObject *__pyx_v_timesteps_until_can_fire = 0;
  PyObject *__pyx_v_ship_heading_rad = NULL;
  PyObject *__pyx_v_avoid_targeting_this_asteroid = 0;
  PyObject *__pyx_v_max_interception_time = NULL;
  PyObject *__pyx_v_culled_targets_for_simulation = 0;
  PyObject *__pyx_v_culled_target_idxs_for_simulation = 0;
  int __pyx_v_feasible_targets_exist;
  PyObject *__pyx_v_min_positive_shot_heading_error_rad = NULL;
  PyObject *__pyx_v_second_min_positive_shot_heading_error_rad = NULL;
  PyObject *__pyx_v_min_negative_shot_heading_error_rad = NULL;
  PyObject *__pyx_v_second_min_negative_shot_heading_error_rad = NULL;
  Py_ssize_t __pyx_v_len_asteroids;
  PyObject *__pyx_v_ast_idx = NULL;
  PyObject *__pyx_v_asteroid = NULL;
  PyObject *__pyx_v_asteroid_when_mine_explodes = NULL;
  PyObject *__pyx_v_delta_x = NULL;
  PyObject *__pyx_v_delta_y = NULL;
  PyObject *__pyx_v_separation = NULL;
  int __pyx_v_check_next_asteroid;
  PyObject *__pyx_v_feasible = NULL;
  PyObject *__pyx_v_shot_heading_error_rad = NULL;
  PyObject *__pyx_v_shot_heading_tolerance_rad = NULL;
  PyObject *__pyx_v_interception_time = NULL;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_v_bullet_sim_timestep_limit = NULL;
  PyObject *__pyx_v_actual_asteroid_hit_at_fire_time = NULL;
  PyObject *__pyx_v_min_shot_heading_error_rad = NULL;
  PyObject *__pyx_v_second_min_shot_heading_error_rad = NULL;
  PyObject *__pyx_v_next_target_heading_error = NULL;
  PyObject *__pyx_v_min_shot_heading_error_deg = NULL;
  PyObject *__pyx_v_altered_turn_command = NULL;
  int __pyx_v_locked_in;
  PyObject *__pyx_v_asteroid_least_shot_heading_error_deg = NULL;
  PyObject *__pyx_v_asteroid_least_shot_heading_tolerance_deg = NULL;
  PyObject *__pyx_v_ship_pred_speed = NULL;
  PyObject *__pyx_v_drag_amount = NULL;
  PyObject *__pyx_v_rad_heading = NULL;
  PyObject *__pyx_v_ship_speed_ts = NULL;
  PyObject *__pyx_v_ship_predicted_pos_x = NULL;
  PyObject *__pyx_v_ship_predicted_pos_y = NULL;
  PyObject *__pyx_v_shot_heading_error_deg = NULL;
  PyObject *__pyx_v_shot_heading_tolerance_deg = NULL;
  double __pyx_v_cos_heading;
  double __pyx_v_sin_heading;
  PyObject *__pyx_v_bullet_x = NULL;
  PyObject *__pyx_v_bullet_y = NULL;
  PyObject *__pyx_v_vx = NULL;
  PyObject *__pyx_v_vy = NULL;
  struct __pyx_obj_14neo_controller_Bullet *__pyx_v_new_bullet = NULL;
  PyObject *__pyx_v_drop_mine_this_timestep = NULL;
  struct __pyx_obj_14neo_controller_Mine *__pyx_v_new_mine = NULL;
  PyObject *__pyx_v_b_idx = NULL;
  PyObject *__pyx_v_b_tail = NULL;
  PyObject *__pyx_v_a_idx = NULL;
  PyObject *__pyx_v_mine_remove_idxs = 0;
  PyObject *__pyx_v_new_asteroids = 0;
  PyObject *__pyx_v_idx_mine = NULL;
  PyObject *__pyx_v_mine = NULL;
  PyObject *__pyx_9genexpr45__pyx_v_a = NULL;
  PyObject *__pyx_9genexpr46__pyx_v_ast_list = NULL;
  PyObject *__pyx_9genexpr46__pyx_v_ast = NULL;
  PyObject *__pyx_9genexpr47__pyx_v_idx = NULL;
  PyObject *__pyx_9genexpr47__pyx_v_bullet = NULL;
  PyObject *__pyx_9genexpr48__pyx_v_ast_idx = NULL;
  PyObject *__pyx_9genexpr49__pyx_v_idx = NULL;
  PyObject *__pyx_9genexpr49__pyx_v_bullet = NULL;
  PyObject *__pyx_9genexpr50__pyx_v_idx = NULL;
  PyObject *__pyx_9genexpr50__pyx_v_mine = NULL;
  PyObject *__pyx_9genexpr51__pyx_v_idx = NULL;
  PyObject *__pyx_9genexpr51__pyx_v_asteroid = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_29);
  __Pyx_XDECREF(__pyx_t_30);
  __Pyx_AddTraceback("neo_controller.Matrix.update", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_return_value);
  __Pyx_XDECREF(__pyx_v_current_set_of_moves_from_list);
  __Pyx_XDECREF(__pyx_v_flattened_asteroids_pending_death);
  __Pyx_XDECREF(__pyx_v_asteroid_remove_idxs);
  __Pyx_XDECREF(__pyx_v_bullet_remove_idxs);
  __Pyx_XDECREF(__pyx_v_b_ind);
  __Pyx_XDECREF(__pyx_v_b);
  __Pyx_XDECREF(__pyx_v_new_bullet_pos);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_actual_asteroid_hit);
  __Pyx_XDECREF(__pyx_v_timesteps_until_bullet_hit_asteroid);
  __Pyx_XDECREF(__pyx_v_ship_was_safe);
  __Pyx_XDECREF(__pyx_v_fire_this_timestep);
  __Pyx_XDECREF(__pyx_v_timesteps_until_can_fire);
  __Pyx_XDECREF(__pyx_v_ship_heading_rad);
  __Pyx_XDECREF(__pyx_v_avoid_targeting_this_asteroid);
  __Pyx_XDECREF(__pyx_v_max_interception_time);
  __Pyx_XDECREF(__pyx_v_culled_targets_for_simulation);
  __Pyx_XDECREF(__pyx_v_culled_target_idxs_for_simulation);
  __Pyx_XDECREF(__pyx_v_min_positive_shot_heading_error_rad);
  __Pyx_XDECREF(__pyx_v_second_min_positive_shot_heading_error_rad);
  __Pyx_XDECREF(__pyx_v_min_negative_shot_heading_error_rad);
  __Pyx_XDECREF(__pyx_v_second_min_negative_shot_heading_error_rad);
  __Pyx_XDECREF(__pyx_v_ast_idx);
  __Pyx_XDECREF(__pyx_v_asteroid);
  __Pyx_XDECREF(__pyx_v_asteroid_when_mine_explodes);
  __Pyx_XDECREF(__pyx_v_delta_x);
  __Pyx_XDECREF(__pyx_v_delta_y);
  __Pyx_XDECREF(__pyx_v_separation);
  __Pyx_XDECREF(__pyx_v_feasible);
  __Pyx_XDECREF(__pyx_v_shot_heading_error_rad);
  __Pyx_XDECREF(__pyx_v_shot_heading_tolerance_rad);
  __Pyx_XDECREF(__pyx_v_interception_time);
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XDECREF(__pyx_v_bullet_sim_timestep_limit);
  __Pyx_XDECREF(__pyx_v_actual_asteroid_hit_at_fire_time);
  __Pyx_XDECREF(__pyx_v_min_shot_heading_error_rad);
  __Pyx_XDECREF(__pyx_v_second_min_shot_heading_error_rad);
  __Pyx_XDECREF(__pyx_v_next_target_heading_error);
  __Pyx_XDECREF(__pyx_v_min_shot_heading_error_deg);
  __Pyx_XDECREF(__pyx_v_altered_turn_command);
  __Pyx_XDECREF(__pyx_v_asteroid_least_shot_heading_error_deg);
  __Pyx_XDECREF(__pyx_v_asteroid_least_shot_heading_tolerance_deg);
  __Pyx_XDECREF(__pyx_v_ship_pred_speed);
  __Pyx_XDECREF(__pyx_v_drag_amount);
  __Pyx_XDECREF(__pyx_v_rad_heading);
  __Pyx_XDECREF(__pyx_v_ship_speed_ts);
  __Pyx_XDECREF(__pyx_v_ship_predicted_pos_x);
  __Pyx_XDECREF(__pyx_v_ship_predicted_pos_y);
  __Pyx_XDECREF(__pyx_v_shot_heading_error_deg);
  __Pyx_XDECREF(__pyx_v_shot_heading_tolerance_deg);
  __Pyx_XDECREF(__pyx_v_bullet_x);
  __Pyx_XDECREF(__pyx_v_bullet_y);
  __Pyx_XDECREF(__pyx_v_vx);
  __Pyx_XDECREF(__pyx_v_vy);
  __Pyx_XDECREF((PyObject *)__pyx_v_new_bullet);
  __Pyx_XDECREF(__pyx_v_drop_mine_this_timestep);
  __Pyx_XDECREF((PyObject *)__pyx_v_new_mine);
  __Pyx_XDECREF(__pyx_v_b_idx);
  __Pyx_XDECREF(__pyx_v_b_tail);
  __Pyx_XDECREF(__pyx_v_a_idx);
  __Pyx_XDECREF(__pyx_v_mine_remove_idxs);
  __Pyx_XDECREF(__pyx_v_new_asteroids);
  __Pyx_XDECREF(__pyx_v_idx_mine);
  __Pyx_XDECREF(__pyx_v_mine);
  __Pyx_XDECREF(__pyx_9genexpr45__pyx_v_a);
  __Pyx_XDECREF(__pyx_9genexpr46__pyx_v_ast_list);
  __Pyx_XDECREF(__pyx_9genexpr46__pyx_v_ast);
  __Pyx_XDECREF(__pyx_9genexpr47__pyx_v_idx);
  __Pyx_XDECREF(__pyx_9genexpr47__pyx_v_bullet);
  __Pyx_XDECREF(__pyx_9genexpr48__pyx_v_ast_idx);
  __Pyx_XDECREF(__pyx_9genexpr49__pyx_v_idx);
  __Pyx_XDECREF(__pyx_9genexpr49__pyx_v_bullet);
  __Pyx_XDECREF(__pyx_9genexpr50__pyx_v_idx);
  __Pyx_XDECREF(__pyx_9genexpr50__pyx_v_mine);
  __Pyx_XDECREF(__pyx_9genexpr51__pyx_v_idx);
  __Pyx_XDECREF(__pyx_9genexpr51__pyx_v_asteroid);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_9 = PyTuple_Pack(6, __pyx_t_3, __pyx_t_2, Py_None, Py_None, Py_None, ((PyObject*)Py_False)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_fire, __pyx_mstate_global->__pyx_kp_u_Optional_bool) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_drop_mine, __pyx_mstate_global->__pyx_kp_u_Optional_bool) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_whole_move_sequence, __pyx_mstate_global->__pyx_kp_u_Optional_list_Action) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_wait_out_mines, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_55update, 0, __pyx_mstate_global->__pyx_n_u_Matrix_update, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[173])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_update, __pyx_t_3) < 0) __PYX_ERR(0, 4876, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 4877:         global total_sim_timesteps  # REMOVE_FOR_COMPETITION

+4878:         total_sim_timesteps += 1  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_total_sim_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_total_sim_timesteps, __pyx_t_2) < 0) __PYX_ERR(0, 4878, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 4879:         #if fire is not None and not wait_out_mines:

 4880:         #    print(f"Calling update in sim {self.sim_id} on future ts {self.future_timesteps} with fire {fire}")

 4881:         #global sim_update_total_time, sim_cull_total_time

+4882:         if ENABLE_BAD_LUCK_EXCEPTION and random.random() < BAD_LUCK_EXCEPTION_PROBABILITY:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ENABLE_BAD_LUCK_EXCEPTION); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4882, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_4) {
  } else {
    __pyx_t_3 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4882, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_BAD_LUCK_EXCEPTION_PROBABILITY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4882, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4882, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __pyx_t_4;
  __pyx_L4_bool_binop_done:;
  if (unlikely(__pyx_t_3)) {
/* … */
  }

+4883:             raise Exception("Bad luck exception!")  # REMOVE_FOR_COMPETITION

    __pyx_t_6 = NULL;
    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
    __pyx_t_2 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_Bad_luck_exception};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4883, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 4883, __pyx_L1_error)

 4884:         #start_time = time.perf_counter()

 4885:         # This should exactly match what kessler_game.py does.

 4886:         # Being even one timestep off is the difference between life and death!!!

+4887:         return_value: Optional[bool] = None

  __Pyx_INCREF(Py_None);
  __pyx_v_return_value = Py_None;

 4888:         '''

 4889:         if not wait_out_mines:

 4890:             if not PRUNE_SIM_STATE_SEQUENCE or self.future_timesteps == 0:

 4891:                 self.state_sequence.append(cast(SimState, {'timestep': self.initial_timestep + self.future_timesteps, 'ship_state': copy.copy(self.ship_state), 'game_state': self.get_game_state(), 'asteroids_pending_death': dict(self.asteroids_pending_death), 'forecasted_asteroid_splits': [copy.copy(a) for a in self.forecasted_asteroid_splits]}))

 4892:             else:

 4893:                 self.state_sequence.append(cast(SimState, {'timestep': self.initial_timestep + self.future_timesteps, 'ship_state': copy.copy(self.ship_state)}))

 4894:         '''

+4895:         if not wait_out_mines:

  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_wait_out_mines); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4895, __pyx_L1_error)
  __pyx_t_4 = (!__pyx_t_3);
  if (__pyx_t_4) {
/* … */
  }

+4896:             if PRUNE_SIM_STATE_SEQUENCE and self.future_timesteps != 0:

    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PRUNE_SIM_STATE_SEQUENCE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4896, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_3) {
    } else {
      __pyx_t_4 = __pyx_t_3;
      goto __pyx_L8_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4896, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_4 = __pyx_t_3;
    __pyx_L8_bool_binop_done:;
    if (__pyx_t_4) {
/* … */
      goto __pyx_L7;
    }

 4897:                 # Create a super lightweight state that omits unnecessary stuff

+4898:                 self.state_sequence.append(SimState(

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4898, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = NULL;
      __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState);
      __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState); 
/* … */
      __pyx_t_12 = __Pyx_PyObject_Append(__pyx_t_1, ((PyObject *)__pyx_t_2)); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 4898, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF((PyObject *)__pyx_t_2); __pyx_t_2 = 0;

+4899:                     timestep=self.initial_timestep + self.future_timesteps,

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4899, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4899, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = PyNumber_Add(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4899, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+4900:                     ship_state=self.ship_state.copy(),

      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4900, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_8 = __pyx_t_11;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
        __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4900, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_6, NULL};
        __pyx_t_11 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4898, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_11);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_10, __pyx_t_11, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4898, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_9, __pyx_t_11, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4898, __pyx_L1_error)
        __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_11);
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4898, __pyx_L1_error)
        __Pyx_GOTREF((PyObject *)__pyx_t_2);
      }

 4901:                     # Assuming game_state and other attributes are optional or have default values in SimState definition

 4902:                 ))

 4903:             else:

+4904:                 self.state_sequence.append(SimState(

    /*else*/ {
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4904, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_5 = NULL;
      __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState);
      __pyx_t_11 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState); 
/* … */
      __pyx_t_12 = __Pyx_PyObject_Append(__pyx_t_2, ((PyObject *)__pyx_t_1)); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 4904, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;
    }
    __pyx_L7:;

+4905:                     timestep=self.initial_timestep + self.future_timesteps,

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4905, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4905, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = PyNumber_Add(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4905, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+4906:                     ship_state=self.ship_state.copy(),

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4906, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = __pyx_t_8;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL};
        __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4906, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
      }

+4907:                     game_state=self.get_game_state(),

      __pyx_t_9 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL};
        __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_game_state, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4907, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }

+4908:                     asteroids_pending_death=dict(self.asteroids_pending_death),

      __pyx_t_13 = NULL;
      __Pyx_INCREF((PyObject *)(&PyDict_Type));
      __pyx_t_14 = ((PyObject *)(&PyDict_Type)); 
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4908, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_15};
        __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4908, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      { /* enter inner scope */

+4909:                     forecasted_asteroid_splits=[a.copy() for a in self.forecasted_asteroid_splits]

        __pyx_t_14 = PyList_New(0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 4909, __pyx_L12_error)
        __Pyx_GOTREF(__pyx_t_14);
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4909, __pyx_L12_error)
        __Pyx_GOTREF(__pyx_t_15);
        if (likely(PyList_CheckExact(__pyx_t_15)) || PyTuple_CheckExact(__pyx_t_15)) {
          __pyx_t_13 = __pyx_t_15; __Pyx_INCREF(__pyx_t_13);
          __pyx_t_16 = 0;
          __pyx_t_17 = NULL;
        } else {
          __pyx_t_16 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4909, __pyx_L12_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 4909, __pyx_L12_error)
        }
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        for (;;) {
          if (likely(!__pyx_t_17)) {
            if (likely(PyList_CheckExact(__pyx_t_13))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4909, __pyx_L12_error)
                #endif
                if (__pyx_t_16 >= __pyx_temp) break;
              }
              __pyx_t_15 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_16);
              ++__pyx_t_16;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4909, __pyx_L12_error)
                #endif
                if (__pyx_t_16 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_15 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_16));
              #else
              __pyx_t_15 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_16);
              #endif
              ++__pyx_t_16;
            }
            if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4909, __pyx_L12_error)
          } else {
            __pyx_t_15 = __pyx_t_17(__pyx_t_13);
            if (unlikely(!__pyx_t_15)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4909, __pyx_L12_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_15);
          __Pyx_XDECREF_SET(__pyx_9genexpr45__pyx_v_a, __pyx_t_15);
          __pyx_t_15 = 0;
          __pyx_t_18 = __pyx_9genexpr45__pyx_v_a;
          __Pyx_INCREF(__pyx_t_18);
          __pyx_t_7 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_18, NULL};
            __pyx_t_15 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
            if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4909, __pyx_L12_error)
            __Pyx_GOTREF(__pyx_t_15);
          }
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_14, (PyObject*)__pyx_t_15))) __PYX_ERR(0, 4909, __pyx_L12_error)
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        }
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_XDECREF(__pyx_9genexpr45__pyx_v_a); __pyx_9genexpr45__pyx_v_a = 0;
        goto __pyx_L16_exit_scope;
        __pyx_L12_error:;
        __Pyx_XDECREF(__pyx_9genexpr45__pyx_v_a); __pyx_9genexpr45__pyx_v_a = 0;
        goto __pyx_L1_error;
        __pyx_L16_exit_scope:;
      } /* exit inner scope */
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_5, NULL};
        __pyx_t_13 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4904, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_6, __pyx_t_13, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 4904, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_10, __pyx_t_13, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 4904, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, __pyx_t_8, __pyx_t_13, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 4904, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_9, __pyx_t_13, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 4904, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_14, __pyx_t_13, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 4904, __pyx_L1_error)
        __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_11, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_13);
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4904, __pyx_L1_error)
        __Pyx_GOTREF((PyObject *)__pyx_t_1);
      }

 4910:                 ))

 4911:         # The simulation starts by evaluating actions and dynamics of the current present timestep, and then steps into the future

 4912:         # The game state we're given is actually what we had at the end of the previous timestep

 4913:         # The game will take the previous state, and apply current actions and then update to get the result of this timestep

+4914:         if whole_move_sequence and ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __pyx_t_3 = (__pyx_v_whole_move_sequence != Py_None)&&(__Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_3 < 0))) __PYX_ERR(0, 4914, __pyx_L1_error)
  if (__pyx_t_3) {
  } else {
    __pyx_t_4 = __pyx_t_3;
    goto __pyx_L18_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4914, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_4 = __pyx_t_3;
  __pyx_L18_bool_binop_done:;
  if (__pyx_t_4) {
/* … */
  }

+4915:             current_set_of_moves_from_list = whole_move_sequence[self.future_timesteps]  # REMOVE_FOR_COMPETITION

    if (unlikely(__pyx_v_whole_move_sequence == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(0, 4915, __pyx_L1_error)
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4915, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_whole_move_sequence, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4915, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_current_set_of_moves_from_list = __pyx_t_2;
    __pyx_t_2 = 0;

+4916:             assert current_set_of_moves_from_list.thrust == thrust  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_current_set_of_moves_from_list, __pyx_mstate_global->__pyx_n_u_thrust); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4916, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_thrust); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4916, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_11 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4916, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4916, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_4)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4916, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4916, __pyx_L1_error)
    #endif

+4917:             assert current_set_of_moves_from_list.turn_rate == turn_rate  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_current_set_of_moves_from_list, __pyx_mstate_global->__pyx_n_u_turn_rate); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4917, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4917, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_2 = PyObject_RichCompare(__pyx_t_11, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4917, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4917, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_4)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 4917, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 4917, __pyx_L1_error)
    #endif

 4918:         # Simulation order:

 4919:         # Ships are given the game state from after the previous timestep. Ships then decide the inputs.

 4920:         # Update bullets/mines/asteroids.

 4921:         # Ship has inputs applied and updated. Any new bullets and mines that the ship creates is added to the list.

 4922:         # Bullets past the map edge get culled

 4923:         # Ships and asteroids beyond the map edge get wrapped

 4924:         # Check for bullet/asteroid collisions. Checked for each bullet in list order, check for each asteroid in list order. Bullets and asteroids are removed here, and any new asteroids created are added to the list now.

 4925:         # Check mine collisions with asteroids/ships. For each mine in list order, check whether it is detonating and if it collides with first asteroids in list order (and add new asteroids to list), and then ships.

 4926:         # Check for asteroid/ship collisions. For each ship in list order, check collisions with each asteroid in list order. New asteroids are added now. Ships and asteroids get culled if they collide.

 4927:         # Check ship/ship collisions and cull them.

 4928: 

+4929:         if self.plot_this_sim and self.game_state_plotter is not None:  # REMOVE_FOR_COMPETITION

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_plot_this_sim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4929, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4929, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_3) {
  } else {
    __pyx_t_4 = __pyx_t_3;
    goto __pyx_L21_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4929, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = (__pyx_t_2 != Py_None);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = __pyx_t_3;
  __pyx_L21_bool_binop_done:;
  if (__pyx_t_4) {
/* … */
  }

 4930:             # print(self.game_state.asteroids)  # REMOVE_FOR_COMPETITION

+4931:             flattened_asteroids_pending_death = [ast for ast_list in self.asteroids_pending_death.values() for ast in ast_list]  # REMOVE_FOR_COMPETITION

    { /* enter inner scope */
      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4931, __pyx_L25_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_16 = 0;
      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4931, __pyx_L25_error)
      __Pyx_GOTREF(__pyx_t_11);
      if (unlikely(__pyx_t_11 == Py_None)) {
        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
        __PYX_ERR(0, 4931, __pyx_L25_error)
      }
      __pyx_t_13 = __Pyx_dict_iterator(__pyx_t_11, 0, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_19), (&__pyx_t_20)); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4931, __pyx_L25_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_XDECREF(__pyx_t_1);
      __pyx_t_1 = __pyx_t_13;
      __pyx_t_13 = 0;
      while (1) {
        __pyx_t_21 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_19, &__pyx_t_16, NULL, &__pyx_t_13, NULL, __pyx_t_20);
        if (unlikely(__pyx_t_21 == 0)) break;
        if (unlikely(__pyx_t_21 == -1)) __PYX_ERR(0, 4931, __pyx_L25_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_XDECREF_SET(__pyx_9genexpr46__pyx_v_ast_list, __pyx_t_13);
        __pyx_t_13 = 0;
        if (likely(PyList_CheckExact(__pyx_9genexpr46__pyx_v_ast_list)) || PyTuple_CheckExact(__pyx_9genexpr46__pyx_v_ast_list)) {
          __pyx_t_13 = __pyx_9genexpr46__pyx_v_ast_list; __Pyx_INCREF(__pyx_t_13);
          __pyx_t_22 = 0;
          __pyx_t_17 = NULL;
        } else {
          __pyx_t_22 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_9genexpr46__pyx_v_ast_list); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4931, __pyx_L25_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 4931, __pyx_L25_error)
        }
        for (;;) {
          if (likely(!__pyx_t_17)) {
            if (likely(PyList_CheckExact(__pyx_t_13))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4931, __pyx_L25_error)
                #endif
                if (__pyx_t_22 >= __pyx_temp) break;
              }
              __pyx_t_11 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_22);
              ++__pyx_t_22;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4931, __pyx_L25_error)
                #endif
                if (__pyx_t_22 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_11 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_22));
              #else
              __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_22);
              #endif
              ++__pyx_t_22;
            }
            if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4931, __pyx_L25_error)
          } else {
            __pyx_t_11 = __pyx_t_17(__pyx_t_13);
            if (unlikely(!__pyx_t_11)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4931, __pyx_L25_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_11);
          __Pyx_XDECREF_SET(__pyx_9genexpr46__pyx_v_ast, __pyx_t_11);
          __pyx_t_11 = 0;
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_9genexpr46__pyx_v_ast))) __PYX_ERR(0, 4931, __pyx_L25_error)
        }
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_9genexpr46__pyx_v_ast); __pyx_9genexpr46__pyx_v_ast = 0;
      __Pyx_XDECREF(__pyx_9genexpr46__pyx_v_ast_list); __pyx_9genexpr46__pyx_v_ast_list = 0;
      goto __pyx_L31_exit_scope;
      __pyx_L25_error:;
      __Pyx_XDECREF(__pyx_9genexpr46__pyx_v_ast); __pyx_9genexpr46__pyx_v_ast = 0;
      __Pyx_XDECREF(__pyx_9genexpr46__pyx_v_ast_list); __pyx_9genexpr46__pyx_v_ast_list = 0;
      goto __pyx_L1_error;
      __pyx_L31_exit_scope:;
    } /* exit inner scope */
    __pyx_v_flattened_asteroids_pending_death = ((PyObject*)__pyx_t_2);
    __pyx_t_2 = 0;

+4932:             self.game_state_plotter.update_plot(self.game_state.asteroids, self.ship_state, self.game_state.bullets, [], [], flattened_asteroids_pending_death, self.forecasted_asteroid_splits, self.game_state.mines, True, 0.1, f'SIM UPDATE TS {self.initial_timestep + self.future_timesteps}')  # REMOVE_FOR_COMPETITION

    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_1 = __pyx_t_13;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __pyx_t_23 = PyNumber_Add(__pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_t_23, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_23 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_SIM_UPDATE_TS, __pyx_t_18); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4932, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[12] = {__pyx_t_1, __pyx_t_14, __pyx_t_11, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_v_flattened_asteroids_pending_death, __pyx_t_6, __pyx_t_15, Py_True, __pyx_mstate_global->__pyx_float_0_1, __pyx_t_23};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update_plot, __pyx_callargs+__pyx_t_7, (12-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4932, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 4933: 

+4934:         asteroid_remove_idxs = set()

  __pyx_t_2 = PySet_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4934, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_asteroid_remove_idxs = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 4935: 

 4936:         # Simulate dynamics of bullets

 4937:         # Kessler will move bullets and cull them in different steps, but we combine them in one operation here

 4938:         # So we need to detect when the bullets are crossing the boundary, and delete them if they try to

 4939:         # Enumerate and track indices to delete

+4940:         bullet_remove_idxs = []

  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_bullet_remove_idxs = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+4941:         for b_ind, b in enumerate(self.game_state.bullets):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  if (likely(PyList_CheckExact(__pyx_t_23)) || PyTuple_CheckExact(__pyx_t_23)) {
    __pyx_t_13 = __pyx_t_23; __Pyx_INCREF(__pyx_t_13);
    __pyx_t_19 = 0;
    __pyx_t_17 = NULL;
  } else {
    __pyx_t_19 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_23); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 4941, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
  for (;;) {
    if (likely(!__pyx_t_17)) {
      if (likely(PyList_CheckExact(__pyx_t_13))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4941, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        __pyx_t_23 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_19);
        ++__pyx_t_19;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4941, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_23 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_19));
        #else
        __pyx_t_23 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_19);
        #endif
        ++__pyx_t_19;
      }
      if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4941, __pyx_L1_error)
    } else {
      __pyx_t_23 = __pyx_t_17(__pyx_t_13);
      if (unlikely(!__pyx_t_23)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4941, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_23);
    __pyx_t_23 = 0;
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_b_ind, __pyx_t_2);
    __pyx_t_23 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_2);
    __pyx_t_2 = __pyx_t_23;
    __pyx_t_23 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+4942:             new_bullet_pos = (b.position[0] + b.velocity[0]*DELTA_TIME, b.position[1] + b.velocity[1]*DELTA_TIME)

    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_23, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_23, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_10 = PyNumber_Multiply(__pyx_t_6, __pyx_t_23); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_23 = PyNumber_Add(__pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_10, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = PyNumber_Multiply(__pyx_t_6, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyNumber_Add(__pyx_t_15, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_GIVEREF(__pyx_t_23);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_23) != (0)) __PYX_ERR(0, 4942, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_10);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 4942, __pyx_L1_error);
    __pyx_t_23 = 0;
    __pyx_t_10 = 0;
    __Pyx_XDECREF_SET(__pyx_v_new_bullet_pos, ((PyObject*)__pyx_t_9));
    __pyx_t_9 = 0;

+4943:             if check_coordinate_bounds(self.game_state, new_bullet_pos[0], new_bullet_pos[1]):

    __pyx_t_10 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4943, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4943, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_23))) {
      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_23);
      assert(__pyx_t_10);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_t_15, __Pyx_PyTuple_GET_ITEM(__pyx_v_new_bullet_pos, 0), __Pyx_PyTuple_GET_ITEM(__pyx_v_new_bullet_pos, 1)};
      __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4943, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4943, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_4) {
/* … */
      goto __pyx_L34;
    }

+4944:                 b.position = new_bullet_pos

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position, __pyx_v_new_bullet_pos) < 0) __PYX_ERR(0, 4944, __pyx_L1_error)

 4945:             else:

+4946:                 bullet_remove_idxs.append(b_ind)

    /*else*/ {
      __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_bullet_remove_idxs, __pyx_v_b_ind); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 4946, __pyx_L1_error)
    }
    __pyx_L34:;

+4947:         if bullet_remove_idxs:

  __pyx_t_4 = (__Pyx_PyList_GET_SIZE(__pyx_v_bullet_remove_idxs) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_4 < 0))) __PYX_ERR(0, 4947, __pyx_L1_error)
  if (__pyx_t_4) {
/* … */
  }

+4948:             self.game_state.bullets = [bullet for idx, bullet in enumerate(self.game_state.bullets) if idx not in bullet_remove_idxs]

    { /* enter inner scope */
      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4948, __pyx_L39_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_13 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4948, __pyx_L39_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4948, __pyx_L39_error)
      __Pyx_GOTREF(__pyx_t_23);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (likely(PyList_CheckExact(__pyx_t_23)) || PyTuple_CheckExact(__pyx_t_23)) {
        __pyx_t_9 = __pyx_t_23; __Pyx_INCREF(__pyx_t_9);
        __pyx_t_19 = 0;
        __pyx_t_17 = NULL;
      } else {
        __pyx_t_19 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_23); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4948, __pyx_L39_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 4948, __pyx_L39_error)
      }
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      for (;;) {
        if (likely(!__pyx_t_17)) {
          if (likely(PyList_CheckExact(__pyx_t_9))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4948, __pyx_L39_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            __pyx_t_23 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_19);
            ++__pyx_t_19;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4948, __pyx_L39_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_23 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_19));
            #else
            __pyx_t_23 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_19);
            #endif
            ++__pyx_t_19;
          }
          if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4948, __pyx_L39_error)
        } else {
          __pyx_t_23 = __pyx_t_17(__pyx_t_9);
          if (unlikely(!__pyx_t_23)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4948, __pyx_L39_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_XDECREF_SET(__pyx_9genexpr47__pyx_v_bullet, __pyx_t_23);
        __pyx_t_23 = 0;
        __Pyx_INCREF(__pyx_t_13);
        __Pyx_XDECREF_SET(__pyx_9genexpr47__pyx_v_idx, __pyx_t_13);
        __pyx_t_23 = __Pyx_PyLong_AddObjC(__pyx_t_13, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4948, __pyx_L39_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_DECREF(__pyx_t_13);
        __pyx_t_13 = __pyx_t_23;
        __pyx_t_23 = 0;
        __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_9genexpr47__pyx_v_idx, __pyx_v_bullet_remove_idxs, Py_NE)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4948, __pyx_L39_error)
        if (__pyx_t_4) {
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_9genexpr47__pyx_v_bullet))) __PYX_ERR(0, 4948, __pyx_L39_error)
        }
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_XDECREF(__pyx_9genexpr47__pyx_v_bullet); __pyx_9genexpr47__pyx_v_bullet = 0;
      __Pyx_XDECREF(__pyx_9genexpr47__pyx_v_idx); __pyx_9genexpr47__pyx_v_idx = 0;
      goto __pyx_L44_exit_scope;
      __pyx_L39_error:;
      __Pyx_XDECREF(__pyx_9genexpr47__pyx_v_bullet); __pyx_9genexpr47__pyx_v_bullet = 0;
      __Pyx_XDECREF(__pyx_9genexpr47__pyx_v_idx); __pyx_9genexpr47__pyx_v_idx = 0;
      goto __pyx_L1_error;
      __pyx_L44_exit_scope:;
    } /* exit inner scope */
    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4948, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_2) < 0) __PYX_ERR(0, 4948, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 4949: 

 4950:         # Update mines

+4951:         for m in self.game_state.mines:

  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4951, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4951, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_13 = __pyx_t_2; __Pyx_INCREF(__pyx_t_13);
    __pyx_t_19 = 0;
    __pyx_t_17 = NULL;
  } else {
    __pyx_t_19 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4951, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 4951, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_17)) {
      if (likely(PyList_CheckExact(__pyx_t_13))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4951, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_19);
        ++__pyx_t_19;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4951, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_19));
        #else
        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_19);
        #endif
        ++__pyx_t_19;
      }
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4951, __pyx_L1_error)
    } else {
      __pyx_t_2 = __pyx_t_17(__pyx_t_13);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4951, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+4952:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4952, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4952, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_4) {
/* … */
    }

+4953:                 assert m.remaining_time > EPS - DELTA_TIME  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4953, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_9 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4953, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4953, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_15 = PyNumber_Subtract(__pyx_t_9, __pyx_t_23); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4953, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = PyObject_RichCompare(__pyx_t_2, __pyx_t_15, Py_GT); __Pyx_XGOTREF(__pyx_t_23); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4953, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_23); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4953, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(!__pyx_t_4)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 4953, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 4953, __pyx_L1_error)
      #endif

+4954:             m.remaining_time -= DELTA_TIME

    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4954, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4954, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_2 = PyNumber_InPlaceSubtract(__pyx_t_23, __pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4954, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time, __pyx_t_2) < 0) __PYX_ERR(0, 4954, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 4955:             # If the timer is below eps, it'll detonate this timestep

 4956:         # Simulate dynamics of asteroids

 4957:         # Wrap the asteroid positions in the same operation

 4958:         # Between when the asteroids get moved and when the future timesteps gets incremented, these asteroids exist at time (self.initial_timestep + self.future_timesteps + 1) instead of (self.initial_timestep + self.future_timesteps)!

+4959:         for a in self.game_state.asteroids:

  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4959, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4959, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_13 = __pyx_t_2; __Pyx_INCREF(__pyx_t_13);
    __pyx_t_19 = 0;
    __pyx_t_17 = NULL;
  } else {
    __pyx_t_19 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4959, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 4959, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_17)) {
      if (likely(PyList_CheckExact(__pyx_t_13))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4959, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_19);
        ++__pyx_t_19;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4959, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_19));
        #else
        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_19);
        #endif
        ++__pyx_t_19;
      }
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4959, __pyx_L1_error)
    } else {
      __pyx_t_2 = __pyx_t_17(__pyx_t_13);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 4959, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+4960:             a.position = ((a.position[0] + a.velocity[0]*DELTA_TIME) % self.game_state.map_size[0], (a.position[1] + a.velocity[1]*DELTA_TIME) % self.game_state.map_size[1])

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_9 = PyNumber_Multiply(__pyx_t_23, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Add(__pyx_t_15, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_15, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_t_15 = PyNumber_Remainder(__pyx_t_2, __pyx_t_9); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = PyNumber_Multiply(__pyx_t_23, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyNumber_Add(__pyx_t_2, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyNumber_Remainder(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_GIVEREF(__pyx_t_15);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_15) != (0)) __PYX_ERR(0, 4960, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_2);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 4960, __pyx_L1_error);
    __pyx_t_15 = 0;
    __pyx_t_2 = 0;
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position, __pyx_t_10) < 0) __PYX_ERR(0, 4960, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+4961:         if not wait_out_mines:

  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_wait_out_mines); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4961, __pyx_L1_error)
  __pyx_t_3 = (!__pyx_t_4);
  if (__pyx_t_3) {
/* … */
  }

+4962:             self.forecasted_asteroid_splits = maintain_forecasted_asteroids(self.forecasted_asteroid_splits, self.game_state)

    __pyx_t_10 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_maintain_forecasted_asteroids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4962, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4962, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4962, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2);
      assert(__pyx_t_10);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_15, __pyx_t_9};
      __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4962, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
    }
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_13) < 0) __PYX_ERR(0, 4962, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 4963:             # Simulate the ship!

 4964:             # Bullet firing happens before we turn the ship

 4965:             # Check whether we want to shoot a simulated bullet

+4966:             if self.ship_state.bullets_remaining != 0:

    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4966, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4966, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __pyx_t_3 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4966, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_3) {
/* … */
      goto __pyx_L53;
    }

+4967:                 if self.fire_first_timestep and self.future_timesteps == 0:

      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_first_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4967, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4967, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (__pyx_t_4) {
      } else {
        __pyx_t_3 = __pyx_t_4;
        goto __pyx_L55_bool_binop_done;
      }
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4967, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4967, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_3 = __pyx_t_4;
      __pyx_L55_bool_binop_done:;
      if (__pyx_t_3) {
/* … */
        goto __pyx_L54;
      }

+4968:                     assert self.respawn_maneuver_pass_number == 0 or (self.respawn_maneuver_pass_number == 2 and self.initial_timestep + self.future_timesteps > self.last_timestep_colliding), f"WTH, {self.respawn_maneuver_pass_number=}, {self.last_timestep_colliding=}, {(self.initial_timestep + self.future_timesteps)=}"  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          if (!__pyx_t_4) {
          } else {
            __pyx_t_3 = __pyx_t_4;
            goto __pyx_L57_bool_binop_done;
          }
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_2, 2, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          if (__pyx_t_4) {
          } else {
            __pyx_t_3 = __pyx_t_4;
            goto __pyx_L57_bool_binop_done;
          }
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_9 = PyNumber_Add(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_2 = PyObject_RichCompare(__pyx_t_9, __pyx_t_13, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4968, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_3 = __pyx_t_4;
          __pyx_L57_bool_binop_done:;
          if (unlikely(!__pyx_t_3)) {
            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_13 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_2), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_9 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_2), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_t_10 = PyNumber_Add(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            __pyx_t_15 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_10), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            __pyx_t_24[0] = __pyx_mstate_global->__pyx_kp_u_WTH_self_respawn_maneuver_pass_n;
            __pyx_t_24[1] = __pyx_t_13;
            __pyx_t_24[2] = __pyx_mstate_global->__pyx_kp_u_self_last_timestep_colliding;
            __pyx_t_24[3] = __pyx_t_9;
            __pyx_t_24[4] = __pyx_mstate_global->__pyx_kp_u_self_initial_timestep_self_futu;
            __pyx_t_24[5] = __pyx_t_15;
            __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_24, 6, 39 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13) + 31 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 50 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_13) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15));
            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4968, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_10, 0, 0);
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            __PYX_ERR(0, 4968, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 4968, __pyx_L1_error)
        #endif

 4969:                     # In theory we should be able to hit the target, however if we're in multiagent mode, the other ship could muddle with things in this time making me miss my shot, so let's just confirm that it's going to land before we fire for real!

 4970:                     # if len(self.other_ships) != 0:

+4971:                     if self.verify_first_shot:

        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_verify_first_shot); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4971, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4971, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (__pyx_t_3) {
/* … */
          goto __pyx_L60;
        }

+4972:                         actual_asteroid_hit, timesteps_until_bullet_hit_asteroid, ship_was_safe = self.bullet_sim(None, False, 0, True, self.future_timesteps, whole_move_sequence)

          __pyx_t_15 = __pyx_v_self;
          __Pyx_INCREF(__pyx_t_15);
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4972, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_7 = 0;
          {
            PyObject *__pyx_callargs[7] = {__pyx_t_15, Py_None, Py_False, __pyx_mstate_global->__pyx_int_0, Py_True, __pyx_t_9, __pyx_v_whole_move_sequence};
            __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_bullet_sim, __pyx_callargs+__pyx_t_7, (7-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4972, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
          }
          if ((likely(PyTuple_CheckExact(__pyx_t_10))) || (PyList_CheckExact(__pyx_t_10))) {
            PyObject* sequence = __pyx_t_10;
            Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
            if (unlikely(size != 3)) {
              if (size > 3) __Pyx_RaiseTooManyValuesError(3);
              else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
              __PYX_ERR(0, 4972, __pyx_L1_error)
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            if (likely(PyTuple_CheckExact(sequence))) {
              __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0);
              __Pyx_INCREF(__pyx_t_9);
              __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1);
              __Pyx_INCREF(__pyx_t_15);
              __pyx_t_13 = PyTuple_GET_ITEM(sequence, 2);
              __Pyx_INCREF(__pyx_t_13);
            } else {
              __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 0);
              if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4972, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_9);
              __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 1);
              if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4972, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_15);
              __pyx_t_13 = __Pyx_PyList_GetItemRef(sequence, 2);
              if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4972, __pyx_L1_error)
              __Pyx_XGOTREF(__pyx_t_13);
            }
            #else
            __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4972, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4972, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_t_13 = __Pyx_PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4972, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            #endif
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          } else {
            Py_ssize_t index = -1;
            __pyx_t_2 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4972, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2);
            index = 0; __pyx_t_9 = __pyx_t_25(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L61_unpacking_failed;
            __Pyx_GOTREF(__pyx_t_9);
            index = 1; __pyx_t_15 = __pyx_t_25(__pyx_t_2); if (unlikely(!__pyx_t_15)) goto __pyx_L61_unpacking_failed;
            __Pyx_GOTREF(__pyx_t_15);
            index = 2; __pyx_t_13 = __pyx_t_25(__pyx_t_2); if (unlikely(!__pyx_t_13)) goto __pyx_L61_unpacking_failed;
            __Pyx_GOTREF(__pyx_t_13);
            if (__Pyx_IternextUnpackEndCheck(__pyx_t_25(__pyx_t_2), 3) < 0) __PYX_ERR(0, 4972, __pyx_L1_error)
            __pyx_t_25 = NULL;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            goto __pyx_L62_unpacking_done;
            __pyx_L61_unpacking_failed:;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_25 = NULL;
            if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
            __PYX_ERR(0, 4972, __pyx_L1_error)
            __pyx_L62_unpacking_done:;
          }
          __pyx_v_actual_asteroid_hit = __pyx_t_9;
          __pyx_t_9 = 0;
          __pyx_v_timesteps_until_bullet_hit_asteroid = __pyx_t_15;
          __pyx_t_15 = 0;
          __pyx_v_ship_was_safe = __pyx_t_13;
          __pyx_t_13 = 0;

 4973:                         # I think this assertion doesn't work right after a ship dies, because their bullet can still be travelling in the air

 4974:                         # if len(self.other_ships) == 0:

 4975:                         #    assert actual_asteroid_hit is not None

+4976:                         if actual_asteroid_hit is None:

          __pyx_t_3 = (__pyx_v_actual_asteroid_hit == Py_None);
          if (__pyx_t_3) {
/* … */
            goto __pyx_L63;
          }

 4977:                             #print(f"SURPRISINGLY WE DON'T HIT ANYTHING LIKE WE THOUGHT WE WOULD!")

+4978:                             fire_this_timestep = False

            __Pyx_INCREF(Py_False);
            __pyx_v_fire_this_timestep = Py_False;

+4979:                             self.cancel_firing_first_timestep = True

            if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cancel_firing_first_timestep, Py_True) < 0) __PYX_ERR(0, 4979, __pyx_L1_error)

 4980:                         else:

 4981:                             # print(f"FIRE FIRST TIMESTEP CONFIRMED WILL HIT!!!")

+4982:                             fire_this_timestep = True

          /*else*/ {
            __Pyx_INCREF(Py_True);
            __pyx_v_fire_this_timestep = Py_True;
          }
          __pyx_L63:;

 4983:                     else:

+4984:                         fire_this_timestep = True

        /*else*/ {
          __Pyx_INCREF(Py_True);
          __pyx_v_fire_this_timestep = Py_True;
        }
        __pyx_L60:;

+4985:                 elif fire is None:

      __pyx_t_3 = (__pyx_v_fire == Py_None);
      if (__pyx_t_3) {
/* … */
        goto __pyx_L54;
      }

 4986:                     #global update_ts_zero_count

 4987:                     # We're able to decide whether we want to fire any convenient shots we can get

+4988:                     timesteps_until_can_fire: int = max(0, FIRE_COOLDOWN_TS - (self.initial_timestep + self.future_timesteps - self.last_timestep_fired))

        __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_FIRE_COOLDOWN_TS); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_9 = PyNumber_Add(__pyx_t_13, __pyx_t_15); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_13 = PyNumber_Subtract(__pyx_t_9, __pyx_t_15); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = PyNumber_Subtract(__pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_26 = 0;
        __pyx_t_10 = __Pyx_PyLong_From_long(__pyx_t_26); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_9 = PyObject_RichCompare(__pyx_t_15, __pyx_t_10, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4988, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (__pyx_t_3) {
          __Pyx_INCREF(__pyx_t_15);
          __pyx_t_13 = __pyx_t_15;
        } else {
          __pyx_t_9 = __Pyx_PyLong_From_long(__pyx_t_26); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4988, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_13 = __pyx_t_9;
          __pyx_t_9 = 0;
        }
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = __pyx_t_13;
        __Pyx_INCREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (!(likely(PyLong_CheckExact(__pyx_t_15))||((__pyx_t_15) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_15))) __PYX_ERR(0, 4988, __pyx_L1_error)
        __pyx_v_timesteps_until_can_fire = ((PyObject*)__pyx_t_15);
        __pyx_t_15 = 0;

 4989:                     #if self.sim_id == 88227:

 4990:                     #    print(f'HELLO were on future ts {self.future_timesteps} in sim 88227 and fire is None. {self.halt_shooting=} {self.respawn_maneuver_pass_number=}, ts until can fire: {timesteps_until_can_fire}, The prescribed thrust and turn rate are {thrust} {turn_rate}')

+4991:                     fire_this_timestep = False

        __Pyx_INCREF(Py_False);
        __pyx_v_fire_this_timestep = Py_False;

+4992:                     ship_heading_rad = radians(self.ship_state.heading)

        __pyx_t_13 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4992, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4992, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4992, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_7 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_9))) {
          __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_9);
          assert(__pyx_t_13);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
          __Pyx_INCREF(__pyx_t_13);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
          __pyx_t_7 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_2};
          __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4992, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_15);
        }
        __pyx_v_ship_heading_rad = __pyx_t_15;
        __pyx_t_15 = 0;

 4993:                     avoid_targeting_this_asteroid: bool

+4994:                     if not self.halt_shooting or (self.respawn_maneuver_pass_number == 2 and self.initial_timestep + self.future_timesteps > self.last_timestep_colliding):

        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_27 = (!__pyx_t_4);
        if (!__pyx_t_27) {
        } else {
          __pyx_t_3 = __pyx_t_27;
          goto __pyx_L65_bool_binop_done;
        }
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_27 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_15, __pyx_mstate_global->__pyx_int_2, 2, 0)); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        if (__pyx_t_27) {
        } else {
          __pyx_t_3 = __pyx_t_27;
          goto __pyx_L65_bool_binop_done;
        }
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_2 = PyNumber_Add(__pyx_t_15, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_15 = PyObject_RichCompare(__pyx_t_2, __pyx_t_9, Py_GT); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 4994, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_3 = __pyx_t_27;
        __pyx_L65_bool_binop_done:;
        if (__pyx_t_3) {
/* … */
        }

+4995:                         if timesteps_until_can_fire == 0:

          __pyx_t_3 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_timesteps_until_can_fire, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4995, __pyx_L1_error)
          if (__pyx_t_3) {
/* … */
            goto __pyx_L68;
          }

 4996:                             # We can shoot this timestep! Loop through all asteroids and see which asteroids we can feasibly hit if we shoot at this angle, and take those and simulate with the bullet sim to see which we'll hit

 4997:                             # If mines exist, then we can't cull any asteroids since asteroids can be hit by the mine and get flung into the path of my shooting

+4998:                             max_interception_time = 0.0

            __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
            __pyx_v_max_interception_time = __pyx_mstate_global->__pyx_float_0_0;

 4999:                             culled_targets_for_simulation: list[Asteroid]

+5000:                             culled_target_idxs_for_simulation: list[int] = []

            __pyx_t_15 = PyList_New(0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5000, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_v_culled_target_idxs_for_simulation = ((PyObject*)__pyx_t_15);
            __pyx_t_15 = 0;

+5001:                             feasible_targets_exist: bool = False

            __pyx_v_feasible_targets_exist = 0;

 5002:                             # Keep track of these so we can begin turning roughly toward our next target

 5003:                             # Keep track of both the positive (left turn) and negative (right turn) ones so we can follow our "random walk" turn schedule

+5004:                             min_positive_shot_heading_error_rad = INFINITY

            __pyx_t_15 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5004, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_v_min_positive_shot_heading_error_rad = __pyx_t_15;
            __pyx_t_15 = 0;

+5005:                             second_min_positive_shot_heading_error_rad = INFINITY

            __pyx_t_15 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5005, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_v_second_min_positive_shot_heading_error_rad = __pyx_t_15;
            __pyx_t_15 = 0;

+5006:                             min_negative_shot_heading_error_rad = INFINITY

            __pyx_t_15 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5006, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_v_min_negative_shot_heading_error_rad = __pyx_t_15;
            __pyx_t_15 = 0;

+5007:                             second_min_negative_shot_heading_error_rad = INFINITY

            __pyx_t_15 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5007, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_v_second_min_negative_shot_heading_error_rad = __pyx_t_15;
            __pyx_t_15 = 0;

+5008:                             len_asteroids = len(self.game_state.asteroids)

            __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5008, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5008, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            __pyx_t_19 = PyObject_Length(__pyx_t_9); if (unlikely(__pyx_t_19 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5008, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_v_len_asteroids = __pyx_t_19;

+5009:                             for ast_idx, asteroid in enumerate(chain(self.game_state.asteroids, self.forecasted_asteroid_splits)):

            __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
            __pyx_t_9 = __pyx_mstate_global->__pyx_int_0;
            __pyx_t_2 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5009, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5009, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5009, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_23);
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5009, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __pyx_t_7 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_13))) {
              __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13);
              assert(__pyx_t_2);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
              __Pyx_INCREF(__pyx_t_2);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
              __pyx_t_7 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_23, __pyx_t_10};
              __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
              __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5009, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_15);
            }
            if (likely(PyList_CheckExact(__pyx_t_15)) || PyTuple_CheckExact(__pyx_t_15)) {
              __pyx_t_13 = __pyx_t_15; __Pyx_INCREF(__pyx_t_13);
              __pyx_t_19 = 0;
              __pyx_t_17 = NULL;
            } else {
              __pyx_t_19 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5009, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5009, __pyx_L1_error)
            }
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            for (;;) {
              if (likely(!__pyx_t_17)) {
                if (likely(PyList_CheckExact(__pyx_t_13))) {
                  {
                    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
                    #if !CYTHON_ASSUME_SAFE_SIZE
                    if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5009, __pyx_L1_error)
                    #endif
                    if (__pyx_t_19 >= __pyx_temp) break;
                  }
                  __pyx_t_15 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_19);
                  ++__pyx_t_19;
                } else {
                  {
                    Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
                    #if !CYTHON_ASSUME_SAFE_SIZE
                    if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5009, __pyx_L1_error)
                    #endif
                    if (__pyx_t_19 >= __pyx_temp) break;
                  }
                  #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                  __pyx_t_15 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_19));
                  #else
                  __pyx_t_15 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_19);
                  #endif
                  ++__pyx_t_19;
                }
                if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5009, __pyx_L1_error)
              } else {
                __pyx_t_15 = __pyx_t_17(__pyx_t_13);
                if (unlikely(!__pyx_t_15)) {
                  PyObject* exc_type = PyErr_Occurred();
                  if (exc_type) {
                    if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5009, __pyx_L1_error)
                    PyErr_Clear();
                  }
                  break;
                }
              }
              __Pyx_GOTREF(__pyx_t_15);
              __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_15);
              __pyx_t_15 = 0;
              __Pyx_INCREF(__pyx_t_9);
              __Pyx_XDECREF_SET(__pyx_v_ast_idx, __pyx_t_9);
              __pyx_t_15 = __Pyx_PyLong_AddObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5009, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_15);
              __Pyx_DECREF(__pyx_t_9);
              __pyx_t_9 = __pyx_t_15;
              __pyx_t_15 = 0;
/* … */
              __pyx_L69_continue:;
            }
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5010:                                 # Loop through ALL asteroids and make sure at least one asteroid is a valid target

 5011:                                 # Get the length of time the longest asteroid would take to hit, and that'll be the upper bound of the bullet sim's timesteps

 5012:                                 # Avoid shooting my size 1 asteroids that are about to get mined by my mine

+5013:                                 avoid_targeting_this_asteroid = False

              __Pyx_INCREF(Py_False);
              __Pyx_XDECREF_SET(__pyx_v_avoid_targeting_this_asteroid, Py_False);

+5014:                                 if asteroid.size == 1:

              __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5014, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_15);
              __pyx_t_3 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_15, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5014, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
              if (__pyx_t_3) {
/* … */
              }

+5015:                                     for m in self.game_state.mines:

                __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5015, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_15);
                __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5015, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_10);
                __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                if (likely(PyList_CheckExact(__pyx_t_10)) || PyTuple_CheckExact(__pyx_t_10)) {
                  __pyx_t_15 = __pyx_t_10; __Pyx_INCREF(__pyx_t_15);
                  __pyx_t_16 = 0;
                  __pyx_t_28 = NULL;
                } else {
                  __pyx_t_16 = -1; __pyx_t_15 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5015, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_28 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_15); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 5015, __pyx_L1_error)
                }
                __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                for (;;) {
                  if (likely(!__pyx_t_28)) {
                    if (likely(PyList_CheckExact(__pyx_t_15))) {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_15);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5015, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      __pyx_t_10 = __Pyx_PyList_GetItemRef(__pyx_t_15, __pyx_t_16);
                      ++__pyx_t_16;
                    } else {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_15);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5015, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                      __pyx_t_10 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_15, __pyx_t_16));
                      #else
                      __pyx_t_10 = __Pyx_PySequence_ITEM(__pyx_t_15, __pyx_t_16);
                      #endif
                      ++__pyx_t_16;
                    }
                    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5015, __pyx_L1_error)
                  } else {
                    __pyx_t_10 = __pyx_t_28(__pyx_t_15);
                    if (unlikely(!__pyx_t_10)) {
                      PyObject* exc_type = PyErr_Occurred();
                      if (exc_type) {
                        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5015, __pyx_L1_error)
                        PyErr_Clear();
                      }
                      break;
                    }
                  }
                  __Pyx_GOTREF(__pyx_t_10);
                  __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_10);
                  __pyx_t_10 = 0;
/* … */
                }
                __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                goto __pyx_L79_for_end;
                __pyx_L73_break:;
                __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                goto __pyx_L79_for_end;
                __pyx_L79_for_end:;

+5016:                                         if m.position in self.mine_positions_placed:

                  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5016, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_10);
                  __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5016, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_23);
                  __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_t_10, __pyx_t_23, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5016, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                  if (__pyx_t_3) {
/* … */
                  }

 5017:                                             # This mine is mine

 5018:                                             #project_asteroid_by_timesteps_num = round(m.remaining_time*FPS)

 5019:                                             #asteroid_when_mine_explodes = time_travel_asteroid(asteroid, project_asteroid_by_timesteps_num, self.game_state)

+5020:                                             asteroid_when_mine_explodes = time_travel_asteroid_s(asteroid, m.remaining_time, self.game_state)

                    __pyx_t_10 = NULL;
                    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid_s); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5020, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5020, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5020, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __pyx_t_7 = 1;
                    #if CYTHON_UNPACK_METHODS
                    if (unlikely(PyMethod_Check(__pyx_t_2))) {
                      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2);
                      assert(__pyx_t_10);
                      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
                      __Pyx_INCREF(__pyx_t_10);
                      __Pyx_INCREF(__pyx__function);
                      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
                      __pyx_t_7 = 0;
                    }
                    #endif
                    {
                      PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_v_asteroid, __pyx_t_6, __pyx_t_8};
                      __pyx_t_23 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
                      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                      if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5020, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_23);
                    }
                    __Pyx_XDECREF_SET(__pyx_v_asteroid_when_mine_explodes, __pyx_t_23);
                    __pyx_t_23 = 0;

 5021:                                             #if check_collision(asteroid_when_mine_explodes.position[0], asteroid_when_mine_explodes.position[1], asteroid_when_mine_explodes.radius, m.position[0], m.position[1], MINE_BLAST_RADIUS):

+5022:                                             delta_x = asteroid_when_mine_explodes.position[0] - m.position[0]

                    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5022, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_23, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5022, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5022, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_23, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5022, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __pyx_t_23 = PyNumber_Subtract(__pyx_t_2, __pyx_t_8); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5022, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_23);
                    __pyx_t_23 = 0;

+5023:                                             delta_y = asteroid_when_mine_explodes.position[1] - m.position[1]

                    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5023, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_23, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5023, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5023, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_23, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5023, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __pyx_t_23 = PyNumber_Subtract(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5023, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_23);
                    __pyx_t_23 = 0;

+5024:                                             separation = asteroid_when_mine_explodes.radius + MINE_BLAST_RADIUS

                    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5024, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5024, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __pyx_t_8 = PyNumber_Add(__pyx_t_23, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5024, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_8);
                    __pyx_t_8 = 0;

+5025:                                             if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

                    __pyx_t_8 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __pyx_t_2 = PyObject_RichCompare(__pyx_t_8, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    if (__pyx_t_27) {
                    } else {
                      __pyx_t_3 = __pyx_t_27;
                      goto __pyx_L76_bool_binop_done;
                    }
                    __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __pyx_t_8 = PyObject_RichCompare(__pyx_t_2, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    if (__pyx_t_27) {
                    } else {
                      __pyx_t_3 = __pyx_t_27;
                      goto __pyx_L76_bool_binop_done;
                    }
                    __pyx_t_8 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __pyx_t_2 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __pyx_t_23 = PyNumber_Add(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __pyx_t_2 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __pyx_t_8 = PyObject_RichCompare(__pyx_t_23, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5025, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __pyx_t_3 = __pyx_t_27;
                    __pyx_L76_bool_binop_done:;
                    if (__pyx_t_3) {
/* … */
                    }

+5026:                                                 avoid_targeting_this_asteroid = True

                      __Pyx_INCREF(Py_True);
                      __Pyx_DECREF_SET(__pyx_v_avoid_targeting_this_asteroid, Py_True);

+5027:                                                 break

                      goto __pyx_L73_break;

+5028:                                 if avoid_targeting_this_asteroid:

              __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_avoid_targeting_this_asteroid); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5028, __pyx_L1_error)
              if (__pyx_t_3) {
/* … */
              }

+5029:                                     continue

                goto __pyx_L69_continue;

+5030:                                 if ast_idx < len_asteroids:

              __pyx_t_15 = PyLong_FromSsize_t(__pyx_v_len_asteroids); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5030, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_15);
              __pyx_t_8 = PyObject_RichCompare(__pyx_v_ast_idx, __pyx_t_15, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5030, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
              __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5030, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (__pyx_t_3) {
/* … */
              }

 5031:                                     #ast_angle = super_fast_atan2(asteroid.position[1] - self.ship_state.position[1], asteroid.position[0] - self.ship_state.position[0])

 5032:                                     #if abs(angle_difference_deg(degrees(ast_angle), self.ship_state.heading)) <= MANEUVER_BULLET_SIM_CULLING_CONE_WIDTH_ANGLE_HALF:

+5033:                                     if heading_diff_within_threshold(ship_heading_rad, asteroid.position[0] - self.ship_state.position[0], asteroid.position[1] - self.ship_state.position[1], MANEUVER_BULLET_SIM_CULLING_CONE_WIDTH_ANGLE_HALF_COSINE):

                __pyx_t_15 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_heading_diff_within_threshold); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_23);
                __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_23, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_6);
                __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_23);
                __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_10);
                __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_23);
                __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                __pyx_t_10 = PyNumber_Subtract(__pyx_t_6, __pyx_t_23); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_10);
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_23);
                __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_23, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_6);
                __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_23);
                __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_11);
                __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_11, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_23);
                __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                __pyx_t_11 = PyNumber_Subtract(__pyx_t_6, __pyx_t_23); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_11);
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_MANEUVER_BULLET_SIM_CULLING_CONE); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_23);
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_2))) {
                  __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_2);
                  assert(__pyx_t_15);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
                  __Pyx_INCREF(__pyx_t_15);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[5] = {__pyx_t_15, __pyx_v_ship_heading_rad, __pyx_t_10, __pyx_t_11, __pyx_t_23};
                  __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5033, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_8);
                }
                __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5033, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                if (__pyx_t_3) {
/* … */
                }

 5034:                                         # We also want to add the surrounding asteroids into the bullet sim, just in case any of them aren't added later in the feasible shots

 5035:                                         # The reasons for them not being added later, is that maybe we already shot at it, so we skipped over it.

 5036:                                         # We should be including all the asteroids we shot at, but unfortunately even including all the asteroids in a cone doesn't guarantee that, so this system still isn't perfect!!

+5037:                                         culled_target_idxs_for_simulation.append(ast_idx)

                  __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_culled_target_idxs_for_simulation, __pyx_v_ast_idx); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5037, __pyx_L1_error)

+5038:                                 check_next_asteroid = False

              __pyx_v_check_next_asteroid = 0;

+5039:                                 if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + 1, self.game_state, asteroid):

              __pyx_t_2 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_23);
              __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_11);
              __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_10);
              __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_15);
              __pyx_t_6 = PyNumber_Add(__pyx_t_10, __pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_6);
              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
              __pyx_t_15 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_15);
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_6);
              __pyx_t_7 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_23))) {
                __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_23);
                assert(__pyx_t_2);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
                __Pyx_INCREF(__pyx_t_2);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
                __pyx_t_7 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[5] = {__pyx_t_2, __pyx_t_11, __pyx_t_15, __pyx_t_6, __pyx_v_asteroid};
                __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
                __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5039, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_8);
              }
              __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5039, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (__pyx_t_3) {
/* … */
              }

+5040:                                     for a in unwrap_asteroid(asteroid, self.game_state.map_size[0], self.game_state.map_size[1], UNWRAP_ASTEROID_TARGET_SELECTION_TIME_HORIZON, True):

                __pyx_t_23 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_unwrap_asteroid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_6);
                __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_15);
                __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_11);
                __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_11, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_15);
                __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_11);
                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_11);
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_UNWRAP_ASTEROID_TARGET_SELECTION); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5040, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_6))) {
                  __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_6);
                  assert(__pyx_t_23);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
                  __Pyx_INCREF(__pyx_t_23);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[6] = {__pyx_t_23, __pyx_v_asteroid, __pyx_t_15, __pyx_t_11, __pyx_t_2, Py_True};
                  __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (6-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                  if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5040, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_8);
                }
                if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) {
                  __pyx_t_6 = __pyx_t_8; __Pyx_INCREF(__pyx_t_6);
                  __pyx_t_16 = 0;
                  __pyx_t_28 = NULL;
                } else {
                  __pyx_t_16 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5040, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __pyx_t_28 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 5040, __pyx_L1_error)
                }
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                for (;;) {
                  if (likely(!__pyx_t_28)) {
                    if (likely(PyList_CheckExact(__pyx_t_6))) {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5040, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_16);
                      ++__pyx_t_16;
                    } else {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5040, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                      __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_16));
                      #else
                      __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_16);
                      #endif
                      ++__pyx_t_16;
                    }
                    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5040, __pyx_L1_error)
                  } else {
                    __pyx_t_8 = __pyx_t_28(__pyx_t_6);
                    if (unlikely(!__pyx_t_8)) {
                      PyObject* exc_type = PyErr_Occurred();
                      if (exc_type) {
                        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5040, __pyx_L1_error)
                        PyErr_Clear();
                      }
                      break;
                    }
                  }
                  __Pyx_GOTREF(__pyx_t_8);
                  __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_8);
                  __pyx_t_8 = 0;
/* … */
                  __pyx_L84_continue:;
                }
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                goto __pyx_L100_for_end;
                __pyx_L85_break:;
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                goto __pyx_L100_for_end;
                __pyx_L100_for_end:;

+5041:                                         if check_next_asteroid:

                  if (__pyx_v_check_next_asteroid) {
/* … */
                  }

+5042:                                             break

                    goto __pyx_L85_break;

 5043:                                         # Since we need to find the minimum shot heading errors, we can't break out of this loop early. We should just go through them all.

 5044:                                         #unwrapped_ast_angle = super_fast_atan2(a.position[1] - self.ship_state.position[1], a.position[0] - self.ship_state.position[0])

 5045:                                         #if abs(angle_difference_deg(degrees(unwrapped_ast_angle), self.ship_state.heading)) > MANEUVER_CONVENIENT_SHOT_CHECKER_CONE_WIDTH_ANGLE_HALF:

+5046:                                         if not heading_diff_within_threshold(ship_heading_rad, a.position[0] - self.ship_state.position[0], a.position[1] - self.ship_state.position[1], MANEUVER_CONVENIENT_SHOT_CHECKER_CONE_WIDTH_ANGLE_HALF_COSINE):

                  __pyx_t_2 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_heading_diff_within_threshold); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_11);
                  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_15, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_23);
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_10);
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                  __pyx_t_10 = PyNumber_Subtract(__pyx_t_23, __pyx_t_15); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_10);
                  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_15, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_23);
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_14);
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_14, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
                  __pyx_t_14 = PyNumber_Subtract(__pyx_t_23, __pyx_t_15); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_14);
                  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_MANEUVER_CONVENIENT_SHOT_CHECKER); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_7 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_11))) {
                    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_11);
                    assert(__pyx_t_2);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
                    __Pyx_INCREF(__pyx_t_2);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
                    __pyx_t_7 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[5] = {__pyx_t_2, __pyx_v_ship_heading_rad, __pyx_t_10, __pyx_t_14, __pyx_t_15};
                    __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
                    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5046, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                  }
                  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5046, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                  __pyx_t_27 = (!__pyx_t_3);
                  if (__pyx_t_27) {
/* … */
                  }

+5047:                                             continue

                    goto __pyx_L84_continue;

 5048:                                         # feasible, shot_heading_error_rad, shot_heading_tolerance_rad, interception_time, intercept_x, intercept_y, asteroid_dist_during_interception

+5049:                                         feasible, shot_heading_error_rad, shot_heading_tolerance_rad, interception_time, _, _, _ = calculate_interception(self.ship_state.position[0], self.ship_state.position[1], a.position[0], a.position[1], a.velocity[0], a.velocity[1], a.radius, self.ship_state.heading, self.game_state)

                  __pyx_t_11 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_calculate_interception); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_14);
                  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_10);
                  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
                  __pyx_t_14 = __Pyx_GetItemInt(__pyx_t_10, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_14);
                  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_10);
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                  __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_10);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_23);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_18);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_29);
                  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                  __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5049, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_29);
                  __pyx_t_7 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_15))) {
                    __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_15);
                    assert(__pyx_t_11);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15);
                    __Pyx_INCREF(__pyx_t_11);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_15, __pyx__function);
                    __pyx_t_7 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[10] = {__pyx_t_11, __pyx_t_14, __pyx_t_10, __pyx_t_23, __pyx_t_1, __pyx_t_18, __pyx_t_5, __pyx_t_2, __pyx_t_30, __pyx_t_29};
                    __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_7, (10-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
                    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
                    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5049, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                  }
                  if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) {
                    PyObject* sequence = __pyx_t_8;
                    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
                    if (unlikely(size != 7)) {
                      if (size > 7) __Pyx_RaiseTooManyValuesError(7);
                      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                      __PYX_ERR(0, 5049, __pyx_L1_error)
                    }
                    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                    if (likely(PyTuple_CheckExact(sequence))) {
                      __pyx_t_15 = PyTuple_GET_ITEM(sequence, 0);
                      __Pyx_INCREF(__pyx_t_15);
                      __pyx_t_29 = PyTuple_GET_ITEM(sequence, 1);
                      __Pyx_INCREF(__pyx_t_29);
                      __pyx_t_30 = PyTuple_GET_ITEM(sequence, 2);
                      __Pyx_INCREF(__pyx_t_30);
                      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 3);
                      __Pyx_INCREF(__pyx_t_2);
                      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 4);
                      __Pyx_INCREF(__pyx_t_5);
                      __pyx_t_18 = PyTuple_GET_ITEM(sequence, 5);
                      __Pyx_INCREF(__pyx_t_18);
                      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 6);
                      __Pyx_INCREF(__pyx_t_1);
                    } else {
                      __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 0);
                      if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5049, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_15);
                      __pyx_t_29 = __Pyx_PyList_GetItemRef(sequence, 1);
                      if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5049, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_29);
                      __pyx_t_30 = __Pyx_PyList_GetItemRef(sequence, 2);
                      if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5049, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_30);
                      __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 3);
                      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5049, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_2);
                      __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 4);
                      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5049, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_5);
                      __pyx_t_18 = __Pyx_PyList_GetItemRef(sequence, 5);
                      if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5049, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_18);
                      __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 6);
                      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5049, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_1);
                    }
                    #else
                    {
                      Py_ssize_t i;
                      PyObject** temps[7] = {&__pyx_t_15,&__pyx_t_29,&__pyx_t_30,&__pyx_t_2,&__pyx_t_5,&__pyx_t_18,&__pyx_t_1};
                      for (i=0; i < 7; i++) {
                        PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 5049, __pyx_L1_error)
                        __Pyx_GOTREF(item);
                        *(temps[i]) = item;
                      }
                    }
                    #endif
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                  } else {
                    Py_ssize_t index = -1;
                    PyObject** temps[7] = {&__pyx_t_15,&__pyx_t_29,&__pyx_t_30,&__pyx_t_2,&__pyx_t_5,&__pyx_t_18,&__pyx_t_1};
                    __pyx_t_23 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5049, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_23);
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_23);
                    for (index=0; index < 7; index++) {
                      PyObject* item = __pyx_t_25(__pyx_t_23); if (unlikely(!item)) goto __pyx_L88_unpacking_failed;
                      __Pyx_GOTREF(item);
                      *(temps[index]) = item;
                    }
                    if (__Pyx_IternextUnpackEndCheck(__pyx_t_25(__pyx_t_23), 7) < 0) __PYX_ERR(0, 5049, __pyx_L1_error)
                    __pyx_t_25 = NULL;
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    goto __pyx_L89_unpacking_done;
                    __pyx_L88_unpacking_failed:;
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __pyx_t_25 = NULL;
                    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
                    __PYX_ERR(0, 5049, __pyx_L1_error)
                    __pyx_L89_unpacking_done:;
                  }
                  __Pyx_XDECREF_SET(__pyx_v_feasible, __pyx_t_15);
                  __pyx_t_15 = 0;
                  __Pyx_XDECREF_SET(__pyx_v_shot_heading_error_rad, __pyx_t_29);
                  __pyx_t_29 = 0;
                  __Pyx_XDECREF_SET(__pyx_v_shot_heading_tolerance_rad, __pyx_t_30);
                  __pyx_t_30 = 0;
                  __Pyx_XDECREF_SET(__pyx_v_interception_time, __pyx_t_2);
                  __pyx_t_2 = 0;
                  __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_5);
                  __pyx_t_5 = 0;
                  __Pyx_DECREF_SET(__pyx_v__, __pyx_t_18);
                  __pyx_t_18 = 0;
                  __Pyx_DECREF_SET(__pyx_v__, __pyx_t_1);
                  __pyx_t_1 = 0;

+5050:                                         if feasible:

                  __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_v_feasible); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5050, __pyx_L1_error)
                  if (__pyx_t_27) {
/* … */
                  }

 5051:                                             # Regardless of whether our heading is close enough to shooting this asteroid, keep track of this, just in case no asteroids are within shooting range this timestep, but we can begin to turn toward it next timestep!

 5052:                                             # if abs(shot_heading_error_rad) < abs(min_shot_heading_error_rad):

 5053:                                             #     second_min_shot_heading_error_rad = min_shot_heading_error_rad

 5054:                                             #     min_shot_heading_error_rad = shot_heading_error_rad

 5055:                                             min_positive_shot_heading_error_rad

+5056:                                             if shot_heading_error_rad >= 0.0:

                    __pyx_t_8 = PyObject_RichCompare(__pyx_v_shot_heading_error_rad, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5056, __pyx_L1_error)
                    __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5056, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    if (__pyx_t_27) {
/* … */
                      goto __pyx_L91;
                    }

+5057:                                                 if shot_heading_error_rad < min_positive_shot_heading_error_rad:

                      __pyx_t_8 = PyObject_RichCompare(__pyx_v_shot_heading_error_rad, __pyx_v_min_positive_shot_heading_error_rad, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5057, __pyx_L1_error)
                      __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5057, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                      if (__pyx_t_27) {
/* … */
                      }

+5058:                                                     second_min_positive_shot_heading_error_rad = min_positive_shot_heading_error_rad

                        __Pyx_INCREF(__pyx_v_min_positive_shot_heading_error_rad);
                        __Pyx_DECREF_SET(__pyx_v_second_min_positive_shot_heading_error_rad, __pyx_v_min_positive_shot_heading_error_rad);

+5059:                                                     min_positive_shot_heading_error_rad = shot_heading_error_rad

                        __Pyx_INCREF(__pyx_v_shot_heading_error_rad);
                        __Pyx_DECREF_SET(__pyx_v_min_positive_shot_heading_error_rad, __pyx_v_shot_heading_error_rad);

 5060:                                             else:

+5061:                                                 if shot_heading_error_rad > min_negative_shot_heading_error_rad:

                    /*else*/ {
                      __pyx_t_8 = PyObject_RichCompare(__pyx_v_shot_heading_error_rad, __pyx_v_min_negative_shot_heading_error_rad, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5061, __pyx_L1_error)
                      __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5061, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                      if (__pyx_t_27) {
/* … */
                      }
                    }
                    __pyx_L91:;

+5062:                                                     second_min_negative_shot_heading_error_rad = min_negative_shot_heading_error_rad

                        __Pyx_INCREF(__pyx_v_min_negative_shot_heading_error_rad);
                        __Pyx_DECREF_SET(__pyx_v_second_min_negative_shot_heading_error_rad, __pyx_v_min_negative_shot_heading_error_rad);

+5063:                                                     min_negative_shot_heading_error_rad = shot_heading_error_rad

                        __Pyx_INCREF(__pyx_v_shot_heading_error_rad);
                        __Pyx_DECREF_SET(__pyx_v_min_negative_shot_heading_error_rad, __pyx_v_shot_heading_error_rad);

+5064:                                             if abs(shot_heading_error_rad) <= shot_heading_tolerance_rad:

                    __pyx_t_8 = __Pyx_PyNumber_Absolute(__pyx_v_shot_heading_error_rad); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5064, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __pyx_t_1 = PyObject_RichCompare(__pyx_t_8, __pyx_v_shot_heading_tolerance_rad, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5064, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5064, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    if (__pyx_t_27) {
/* … */
                    }

 5065:                                                 # If we shoot at our current heading, this asteroid can be hit!

+5066:                                                 if ast_idx < len_asteroids:

                      __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_len_asteroids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5066, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_1);
                      __pyx_t_8 = PyObject_RichCompare(__pyx_v_ast_idx, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5066, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                      __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5066, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                      if (__pyx_t_27) {
/* … */
                      }

 5067:                                                     # Only add real asteroids to the set of asteroids we simulate! Don't simulate the asteroids that don't exist yet.

 5068:                                                     #culled_targets_for_simulation.append(asteroid)

+5069:                                                     if not culled_target_idxs_for_simulation or culled_target_idxs_for_simulation[-1] != ast_idx:

                        __pyx_t_3 = (__Pyx_PyList_GET_SIZE(__pyx_v_culled_target_idxs_for_simulation) != 0);
                        if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_3 < 0))) __PYX_ERR(0, 5069, __pyx_L1_error)
                        __pyx_t_4 = (!__pyx_t_3);
                        if (!__pyx_t_4) {
                        } else {
                          __pyx_t_27 = __pyx_t_4;
                          goto __pyx_L97_bool_binop_done;
                        }
                        __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_culled_target_idxs_for_simulation, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5069, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_8);
                        __pyx_t_1 = PyObject_RichCompare(__pyx_t_8, __pyx_v_ast_idx, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5069, __pyx_L1_error)
                        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5069, __pyx_L1_error)
                        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                        __pyx_t_27 = __pyx_t_4;
                        __pyx_L97_bool_binop_done:;
                        if (__pyx_t_27) {
/* … */
                        }

+5070:                                                         culled_target_idxs_for_simulation.append(ast_idx)

                          __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_culled_target_idxs_for_simulation, __pyx_v_ast_idx); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5070, __pyx_L1_error)

+5071:                                                 feasible_targets_exist = True

                      __pyx_v_feasible_targets_exist = 1;

 5072:                                                 #print(f"Adding feasible target idx {ast_idx}, while the max idx for a real ast is {len(self.game_state.asteroids) - 1}")

+5073:                                                 if interception_time > max_interception_time:

                      __pyx_t_1 = PyObject_RichCompare(__pyx_v_interception_time, __pyx_v_max_interception_time, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5073, __pyx_L1_error)
                      __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5073, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                      if (__pyx_t_27) {
/* … */
                      }

+5074:                                                     max_interception_time = interception_time

                        __Pyx_INCREF(__pyx_v_interception_time);
                        __Pyx_DECREF_SET(__pyx_v_max_interception_time, __pyx_v_interception_time);

+5075:                                                 check_next_asteroid = True

                      __pyx_v_check_next_asteroid = 1;

+5076:                                                 break

                      goto __pyx_L85_break;

+5077:                             if feasible_targets_exist:

            if (__pyx_v_feasible_targets_exist) {
/* … */
            }

 5078:                                 #if self.sim_id == 88227:

 5079:                                 #    print(f"Feasible targets exist! {culled_target_idxs_for_simulation=}")

 5080:                                 # Use the bullet sim to confirm that this will hit something

 5081:                                 # There's technically a chance for culled_targets_for_simulation to be empty at this point, if we're purely shooting asteroids that haven't come into existence yet. In that case, this will detect that and will avoid doing the culling, and do the full sim. This should be rare.

 5082:                                 #culled_targets_for_simulation = [asteroid for ast_idx, asteroid in enumerate(self.game_state.asteroids) if ast_idx in culled_target_idxs_for_simulation]

 5083:                                 #print(f"{len(self.game_state.asteroids)=}, {len(culled_target_idxs_for_simulation)=}, ratio={len(self.game_state.asteroids)/len(culled_target_idxs_for_simulation)}")

 5084: 

 5085:                                 '''

 5086:                                 # Convert the list to a set to remove any duplicates

 5087:                                 unique_set = set(culled_target_idxs_for_simulation)

 5088: 

 5089:                                 # Convert the set back to a list

 5090:                                 unique_list = list(unique_set)

 5091: 

 5092:                                 # Sort both lists in ascending order

 5093:                                 unique_list.sort()

 5094: 

 5095:                                 # Verify that both lists are the same and their lengths are the same

 5096:                                 assert culled_target_idxs_for_simulation == unique_list, "Lists are not identical or contain duplicates"

 5097:                                 assert len(culled_target_idxs_for_simulation) == len(unique_list), "List lengths are not equal"

 5098:                                 '''

 5099: 

+5100:                                 culled_targets_for_simulation = [self.game_state.asteroids[ast_idx] for ast_idx in culled_target_idxs_for_simulation]

              { /* enter inner scope */
                __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5100, __pyx_L105_error)
                __Pyx_GOTREF(__pyx_t_9);
                __pyx_t_13 = __pyx_v_culled_target_idxs_for_simulation; __Pyx_INCREF(__pyx_t_13);
                __pyx_t_19 = 0;
                for (;;) {
                  {
                    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
                    #if !CYTHON_ASSUME_SAFE_SIZE
                    if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5100, __pyx_L105_error)
                    #endif
                    if (__pyx_t_19 >= __pyx_temp) break;
                  }
                  __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_19);
                  ++__pyx_t_19;
                  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5100, __pyx_L105_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __Pyx_XDECREF_SET(__pyx_9genexpr48__pyx_v_ast_idx, __pyx_t_6);
                  __pyx_t_6 = 0;
                  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5100, __pyx_L105_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5100, __pyx_L105_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                  __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_9genexpr48__pyx_v_ast_idx); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5100, __pyx_L105_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                  if (unlikely(__Pyx_ListComp_Append(__pyx_t_9, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 5100, __pyx_L105_error)
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                }
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                __Pyx_XDECREF(__pyx_9genexpr48__pyx_v_ast_idx); __pyx_9genexpr48__pyx_v_ast_idx = 0;
                goto __pyx_L109_exit_scope;
                __pyx_L105_error:;
                __Pyx_XDECREF(__pyx_9genexpr48__pyx_v_ast_idx); __pyx_9genexpr48__pyx_v_ast_idx = 0;
                goto __pyx_L1_error;
                __pyx_L109_exit_scope:;
              } /* exit inner scope */
              __pyx_v_culled_targets_for_simulation = ((PyObject*)__pyx_t_9);
              __pyx_t_9 = 0;

 5101:                                 #if not culled_targets_for_simulation:

 5102:                                 #    print("WARNING: culled_targets_for_simulation is empty, so I think this means we're purely shooting at forecasted asteroid splits. Doing the full sim with all the bullets without the culling.")

 5103:                                     #raise Exception()

+5104:                                 bullet_sim_timestep_limit = ceil(max_interception_time*FPS) + 1 # TODO: Might not need +1, but maybe it's safer to have it anyway at the cost of a tiny bit of performance

              __pyx_t_13 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ceil); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5104, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_6);
              __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5104, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_8 = PyNumber_Multiply(__pyx_v_max_interception_time, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5104, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_8);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __pyx_t_7 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_6))) {
                __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6);
                assert(__pyx_t_13);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
                __Pyx_INCREF(__pyx_t_13);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
                __pyx_t_7 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_8};
                __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5104, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
              }
              __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5104, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_6);
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              __pyx_v_bullet_sim_timestep_limit = __pyx_t_6;
              __pyx_t_6 = 0;

+5105:                                 actual_asteroid_hit, timesteps_until_bullet_hit_asteroid, ship_was_safe = self.bullet_sim(None, False, 0, True, self.future_timesteps, whole_move_sequence, bullet_sim_timestep_limit, culled_targets_for_simulation if (culled_targets_for_simulation and not self.game_state.mines) else None)

              __pyx_t_9 = __pyx_v_self;
              __Pyx_INCREF(__pyx_t_9);
              __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5105, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_8);
              __pyx_t_4 = (__Pyx_PyList_GET_SIZE(__pyx_v_culled_targets_for_simulation) != 0);
              if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_4 < 0))) __PYX_ERR(0, 5105, __pyx_L1_error)
              if (__pyx_t_4) {
              } else {
                __pyx_t_27 = __pyx_t_4;
                goto __pyx_L110_bool_binop_done;
              }
              __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5105, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5105, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_18);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5105, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              __pyx_t_3 = (!__pyx_t_4);
              __pyx_t_27 = __pyx_t_3;
              __pyx_L110_bool_binop_done:;
              if (__pyx_t_27) {
                __Pyx_INCREF(__pyx_v_culled_targets_for_simulation);
                __pyx_t_13 = __pyx_v_culled_targets_for_simulation;
              } else {
                __Pyx_INCREF(Py_None);
                __pyx_t_13 = Py_None;
              }
              __pyx_t_7 = 0;
              {
                PyObject *__pyx_callargs[9] = {__pyx_t_9, Py_None, Py_False, __pyx_mstate_global->__pyx_int_0, Py_True, __pyx_t_8, __pyx_v_whole_move_sequence, __pyx_v_bullet_sim_timestep_limit, __pyx_t_13};
                __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_bullet_sim, __pyx_callargs+__pyx_t_7, (9-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5105, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_6);
              }
              if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
                PyObject* sequence = __pyx_t_6;
                Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
                if (unlikely(size != 3)) {
                  if (size > 3) __Pyx_RaiseTooManyValuesError(3);
                  else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                  __PYX_ERR(0, 5105, __pyx_L1_error)
                }
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                if (likely(PyTuple_CheckExact(sequence))) {
                  __pyx_t_13 = PyTuple_GET_ITEM(sequence, 0);
                  __Pyx_INCREF(__pyx_t_13);
                  __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1);
                  __Pyx_INCREF(__pyx_t_8);
                  __pyx_t_9 = PyTuple_GET_ITEM(sequence, 2);
                  __Pyx_INCREF(__pyx_t_9);
                } else {
                  __pyx_t_13 = __Pyx_PyList_GetItemRef(sequence, 0);
                  if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5105, __pyx_L1_error)
                  __Pyx_XGOTREF(__pyx_t_13);
                  __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 1);
                  if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5105, __pyx_L1_error)
                  __Pyx_XGOTREF(__pyx_t_8);
                  __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 2);
                  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5105, __pyx_L1_error)
                  __Pyx_XGOTREF(__pyx_t_9);
                }
                #else
                __pyx_t_13 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5105, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_13);
                __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5105, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_8);
                __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5105, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
                #endif
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              } else {
                Py_ssize_t index = -1;
                __pyx_t_18 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5105, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_18);
                index = 0; __pyx_t_13 = __pyx_t_25(__pyx_t_18); if (unlikely(!__pyx_t_13)) goto __pyx_L112_unpacking_failed;
                __Pyx_GOTREF(__pyx_t_13);
                index = 1; __pyx_t_8 = __pyx_t_25(__pyx_t_18); if (unlikely(!__pyx_t_8)) goto __pyx_L112_unpacking_failed;
                __Pyx_GOTREF(__pyx_t_8);
                index = 2; __pyx_t_9 = __pyx_t_25(__pyx_t_18); if (unlikely(!__pyx_t_9)) goto __pyx_L112_unpacking_failed;
                __Pyx_GOTREF(__pyx_t_9);
                if (__Pyx_IternextUnpackEndCheck(__pyx_t_25(__pyx_t_18), 3) < 0) __PYX_ERR(0, 5105, __pyx_L1_error)
                __pyx_t_25 = NULL;
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                goto __pyx_L113_unpacking_done;
                __pyx_L112_unpacking_failed:;
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __pyx_t_25 = NULL;
                if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
                __PYX_ERR(0, 5105, __pyx_L1_error)
                __pyx_L113_unpacking_done:;
              }
              __pyx_v_actual_asteroid_hit = __pyx_t_13;
              __pyx_t_13 = 0;
              __pyx_v_timesteps_until_bullet_hit_asteroid = __pyx_t_8;
              __pyx_t_8 = 0;
              __pyx_v_ship_was_safe = __pyx_t_9;
              __pyx_t_9 = 0;

+5106:                                 if actual_asteroid_hit is not None and ship_was_safe:

              __pyx_t_3 = (__pyx_v_actual_asteroid_hit != Py_None);
              if (__pyx_t_3) {
              } else {
                __pyx_t_27 = __pyx_t_3;
                goto __pyx_L115_bool_binop_done;
              }
              __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_ship_was_safe); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5106, __pyx_L1_error)
              __pyx_t_27 = __pyx_t_3;
              __pyx_L115_bool_binop_done:;
              if (__pyx_t_27) {
/* … */
              }

 5107:                                     # Confirmed that the shot will land

+5108:                                     assert timesteps_until_bullet_hit_asteroid is not None

                #ifndef CYTHON_WITHOUT_ASSERTIONS
                if (unlikely(__pyx_assertions_enabled())) {
                  __pyx_t_27 = (__pyx_v_timesteps_until_bullet_hit_asteroid != Py_None);
                  if (unlikely(!__pyx_t_27)) {
                    __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
                    __PYX_ERR(0, 5108, __pyx_L1_error)
                  }
                }
                #else
                if ((1)); else __PYX_ERR(0, 5108, __pyx_L1_error)
                #endif

+5109:                                     actual_asteroid_hit_at_fire_time = time_travel_asteroid(actual_asteroid_hit, -timesteps_until_bullet_hit_asteroid, self.game_state)

                __pyx_t_9 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5109, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_8);
                __pyx_t_13 = PyNumber_Negative(__pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5109, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_13);
                __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5109, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_8))) {
                  __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
                  assert(__pyx_t_9);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
                  __Pyx_INCREF(__pyx_t_9);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[4] = {__pyx_t_9, __pyx_v_actual_asteroid_hit, __pyx_t_13, __pyx_t_18};
                  __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5109, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                }
                __pyx_v_actual_asteroid_hit_at_fire_time = __pyx_t_6;
                __pyx_t_6 = 0;

+5110:                                     if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + 1, self.game_state, actual_asteroid_hit_at_fire_time):

                __pyx_t_8 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_13);
                __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
                __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_1);
                __pyx_t_5 = PyNumber_Add(__pyx_t_9, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_5);
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_1);
                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_5);
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_18))) {
                  __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_18);
                  assert(__pyx_t_8);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18);
                  __Pyx_INCREF(__pyx_t_8);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_18, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[5] = {__pyx_t_8, __pyx_t_13, __pyx_t_1, __pyx_t_5, __pyx_v_actual_asteroid_hit_at_fire_time};
                  __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_18, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5110, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                }
                __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5110, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                if (__pyx_t_27) {
/* … */
                }

 5111:                                         #if self.sim_id == 13939:

 5112:                                         #    print(f"Checked on ts {self.initial_timestep + self.future_timesteps + 1} that the asteroid {actual_asteroid_hit_at_fire_time} isn't tracked, so we can shoot it!")

+5113:                                         fire_this_timestep = True

                  __Pyx_INCREF(Py_True);
                  __Pyx_DECREF_SET(__pyx_v_fire_this_timestep, Py_True);

+5114:                                         self.asteroids_shot += 1

                  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5114, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __pyx_t_18 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5114, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_18);
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_t_18) < 0) __PYX_ERR(0, 5114, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

+5115:                                         self.explanation_messages.append("During the maneuver, I conveniently shot asteroids.")

                  __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5115, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_18);
                  __pyx_t_12 = __Pyx_PyObject_Append(__pyx_t_18, __pyx_mstate_global->__pyx_kp_u_During_the_maneuver_I_convenient); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5115, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

+5116:                                         if actual_asteroid_hit_at_fire_time.size != 1:

                  __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_actual_asteroid_hit_at_fire_time, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5116, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_18);
                  __pyx_t_27 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_18, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5116, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                  if (__pyx_t_27) {
/* … */
                  }

 5117:                                             #print("Calling forecast ast bull splits from maneuver")

+5118:                                             self.forecasted_asteroid_splits.extend(forecast_asteroid_bullet_splits_from_heading(actual_asteroid_hit_at_fire_time, timesteps_until_bullet_hit_asteroid, self.ship_state.heading, self.game_state))

                    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5118, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_6 = __pyx_t_5;
                    __Pyx_INCREF(__pyx_t_6);
                    __pyx_t_13 = NULL;
                    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_bullet_splits); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5118, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5118, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_9);
                    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5118, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5118, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_9);
                    __pyx_t_7 = 1;
                    #if CYTHON_UNPACK_METHODS
                    if (unlikely(PyMethod_Check(__pyx_t_8))) {
                      __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_8);
                      assert(__pyx_t_13);
                      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
                      __Pyx_INCREF(__pyx_t_13);
                      __Pyx_INCREF(__pyx__function);
                      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
                      __pyx_t_7 = 0;
                    }
                    #endif
                    {
                      PyObject *__pyx_callargs[5] = {__pyx_t_13, __pyx_v_actual_asteroid_hit_at_fire_time, __pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_t_2, __pyx_t_9};
                      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
                      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5118, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_1);
                    }
                    __pyx_t_7 = 0;
                    {
                      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1};
                      __pyx_t_18 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
                      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                      if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5118, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_18);
                    }
                    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

 5119:                                         # The reason we add one to the timestep we track on, is that once we updated the asteroids' position in the update loop, it's technically the asteroid positions in the game state of the next timestep that gets passed to the controllers!

 5120:                                         # So the asteroid positions at a certain timestep is before their positions get updated. After updating, it's the next timestep.

 5121:                                         #if is_close(-10.0, actual_asteroid_hit_at_fire_time.velocity[0]):

 5122:                                         #    print(f"\nSHOT AT THE ASTEROID IN UPDATE in sim {self.sim_id} on timestep {self.initial_timestep + self.future_timesteps + 1}, {self.initial_timestep=} {self.future_timesteps=} and this shot will take this many ts: {timesteps_until_bullet_hit_asteroid}")

+5123:                                         track_asteroid_we_shot_at(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + 1, self.game_state, timesteps_until_bullet_hit_asteroid, actual_asteroid_hit_at_fire_time)

                  __pyx_t_5 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_track_asteroid_we_shot_at); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5123, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5123, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5123, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_8);
                  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5123, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __pyx_t_2 = PyNumber_Add(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5123, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5123, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5123, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_7 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_1))) {
                    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
                    assert(__pyx_t_5);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
                    __Pyx_INCREF(__pyx_t_5);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
                    __pyx_t_7 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[6] = {__pyx_t_5, __pyx_t_6, __pyx_t_9, __pyx_t_2, __pyx_v_timesteps_until_bullet_hit_asteroid, __pyx_v_actual_asteroid_hit_at_fire_time};
                    __pyx_t_18 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_7, (6-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5123, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_18);
                  }
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

+5124:                                     if fire_this_timestep and not isinf(self.game_state.time_limit) and self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid > floor(FPS*self.game_state.time_limit):

                __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_fire_this_timestep); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5124, __pyx_L1_error)
                if (__pyx_t_3) {
                } else {
                  __pyx_t_27 = __pyx_t_3;
                  goto __pyx_L120_bool_binop_done;
                }
                __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_1);
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __pyx_t_31 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_31 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __pyx_t_3 = (!(isinf(__pyx_t_31) != 0));
                if (__pyx_t_3) {
                } else {
                  __pyx_t_27 = __pyx_t_3;
                  goto __pyx_L120_bool_binop_done;
                }
                __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_1);
                __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_18); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __pyx_t_18 = PyNumber_Add(__pyx_t_2, __pyx_v_timesteps_until_bullet_hit_asteroid); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                __pyx_t_1 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
                __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_6);
                __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_5);
                __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_8);
                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                __pyx_t_5 = PyNumber_Multiply(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_5);
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_9))) {
                  __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
                  assert(__pyx_t_1);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
                  __Pyx_INCREF(__pyx_t_1);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_5};
                  __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5124, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                }
                __pyx_t_9 = PyObject_RichCompare(__pyx_t_18, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5124, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                __pyx_t_27 = __pyx_t_3;
                __pyx_L120_bool_binop_done:;
                if (__pyx_t_27) {
/* … */
                }

 5125:                                         # Added one to the timesteps to prevent off by one :P

 5126:                                         #print(f'WITHHOLDING SHOT BECAUSE SCENARIO IS ENDING, self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid + 1 = {self.initial_timestep + self.future_timesteps + timesteps_until_bullet_hit_asteroid + 1}, {self.game_state.time_limit=}, {FPS*self.game_state.time_limit=}')

+5127:                                         fire_this_timestep = False

                  __Pyx_INCREF(Py_False);
                  __Pyx_DECREF_SET(__pyx_v_fire_this_timestep, Py_False);

+5128:                                         self.asteroids_shot -= 1

                  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5128, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __pyx_t_2 = __Pyx_PyLong_SubtractObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5128, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_t_2) < 0) __PYX_ERR(0, 5128, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+5129:                             assert self.asteroids_shot >= 0  # REMOVE_FOR_COMPETITION

            #ifndef CYTHON_WITHOUT_ASSERTIONS
            if (unlikely(__pyx_assertions_enabled())) {
              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5129, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_2);
              __pyx_t_9 = PyObject_RichCompare(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5129, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5129, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              if (unlikely(!__pyx_t_27)) {
                __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
                __PYX_ERR(0, 5129, __pyx_L1_error)
              }
            }
            #else
            if ((1)); else __PYX_ERR(0, 5129, __pyx_L1_error)
            #endif

+5130:                             if self.respawn_maneuver_pass_number == 0 and (self.future_timesteps >= MANEUVER_SIM_DISALLOW_TARGETING_FOR_START_TIMESTEPS_AMOUNT):# or not fire_this_timestep):

            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5130, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_3 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5130, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (__pyx_t_3) {
            } else {
              __pyx_t_27 = __pyx_t_3;
              goto __pyx_L124_bool_binop_done;
            }
            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5130, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MANEUVER_SIM_DISALLOW_TARGETING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5130, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_18 = PyObject_RichCompare(__pyx_t_9, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_18); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5130, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5130, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __pyx_t_27 = __pyx_t_3;
            __pyx_L124_bool_binop_done:;
            if (__pyx_t_27) {
/* … */
            }

 5131:                                 # Might as well start turning toward our next target!

+5132:                                 if self.asteroids_shot >= RANDOM_WALK_SCHEDULE_LENGTH:

              __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5132, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_18);
              __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_RANDOM_WALK_SCHEDULE_LENGTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5132, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_2);
              __pyx_t_9 = PyObject_RichCompare(__pyx_t_18, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5132, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5132, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              if (__pyx_t_27) {
/* … */
                goto __pyx_L126;
              }

 5133:                                     # Can turn either left or right

 5134:                                     # Find the min absolute shot heading error

+5135:                                     if min_positive_shot_heading_error_rad + min_negative_shot_heading_error_rad >= 0.0:

                __pyx_t_9 = PyNumber_Add(__pyx_v_min_positive_shot_heading_error_rad, __pyx_v_min_negative_shot_heading_error_rad); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5135, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
                __pyx_t_2 = PyObject_RichCompare(__pyx_t_9, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5135, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5135, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                if (__pyx_t_27) {
/* … */
                  goto __pyx_L127;
                }

+5136:                                         min_shot_heading_error_rad = min_negative_shot_heading_error_rad

                  __Pyx_INCREF(__pyx_v_min_negative_shot_heading_error_rad);
                  __pyx_v_min_shot_heading_error_rad = __pyx_v_min_negative_shot_heading_error_rad;

 5137:                                     else:

+5138:                                         min_shot_heading_error_rad = min_positive_shot_heading_error_rad

                /*else*/ {
                  __Pyx_INCREF(__pyx_v_min_positive_shot_heading_error_rad);
                  __pyx_v_min_shot_heading_error_rad = __pyx_v_min_positive_shot_heading_error_rad;
                }
                __pyx_L127:;

+5139:                                     if second_min_positive_shot_heading_error_rad + second_min_negative_shot_heading_error_rad >= 0.0:

                __pyx_t_2 = PyNumber_Add(__pyx_v_second_min_positive_shot_heading_error_rad, __pyx_v_second_min_negative_shot_heading_error_rad); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5139, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __pyx_t_9 = PyObject_RichCompare(__pyx_t_2, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5139, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5139, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                if (__pyx_t_27) {
/* … */
                  goto __pyx_L128;
                }

+5140:                                         second_min_shot_heading_error_rad = second_min_negative_shot_heading_error_rad

                  __Pyx_INCREF(__pyx_v_second_min_negative_shot_heading_error_rad);
                  __pyx_v_second_min_shot_heading_error_rad = __pyx_v_second_min_negative_shot_heading_error_rad;

 5141:                                     else:

+5142:                                         second_min_shot_heading_error_rad = second_min_positive_shot_heading_error_rad

                /*else*/ {
                  __Pyx_INCREF(__pyx_v_second_min_positive_shot_heading_error_rad);
                  __pyx_v_second_min_shot_heading_error_rad = __pyx_v_second_min_positive_shot_heading_error_rad;
                }
                __pyx_L128:;

+5143:                                 elif self.random_walk_schedule[self.asteroids_shot]:

              __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_random_walk_schedule); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5143, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5143, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_2);
              __pyx_t_18 = __Pyx_PyObject_GetItem(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5143, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_18);
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5143, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              if (__pyx_t_27) {
/* … */
                goto __pyx_L126;
              }

 5144:                                     # We want to turn left

+5145:                                     min_shot_heading_error_rad = min_positive_shot_heading_error_rad

                __Pyx_INCREF(__pyx_v_min_positive_shot_heading_error_rad);
                __pyx_v_min_shot_heading_error_rad = __pyx_v_min_positive_shot_heading_error_rad;

+5146:                                     second_min_shot_heading_error_rad = second_min_positive_shot_heading_error_rad

                __Pyx_INCREF(__pyx_v_second_min_positive_shot_heading_error_rad);
                __pyx_v_second_min_shot_heading_error_rad = __pyx_v_second_min_positive_shot_heading_error_rad;

 5147:                                 else:

 5148:                                     # We want to turn right

+5149:                                     min_shot_heading_error_rad = min_negative_shot_heading_error_rad

              /*else*/ {
                __Pyx_INCREF(__pyx_v_min_negative_shot_heading_error_rad);
                __pyx_v_min_shot_heading_error_rad = __pyx_v_min_negative_shot_heading_error_rad;

+5150:                                     second_min_shot_heading_error_rad = second_min_negative_shot_heading_error_rad

                __Pyx_INCREF(__pyx_v_second_min_negative_shot_heading_error_rad);
                __pyx_v_second_min_shot_heading_error_rad = __pyx_v_second_min_negative_shot_heading_error_rad;
              }
              __pyx_L126:;

+5151:                                 if not fire_this_timestep and not isinf(min_shot_heading_error_rad):

              __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_fire_this_timestep); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5151, __pyx_L1_error)
              __pyx_t_4 = (!__pyx_t_3);
              if (__pyx_t_4) {
              } else {
                __pyx_t_27 = __pyx_t_4;
                goto __pyx_L130_bool_binop_done;
              }
              __pyx_t_31 = __Pyx_PyFloat_AsDouble(__pyx_v_min_shot_heading_error_rad); if (unlikely((__pyx_t_31 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5151, __pyx_L1_error)
              __pyx_t_4 = (!(isinf(__pyx_t_31) != 0));
              __pyx_t_27 = __pyx_t_4;
              __pyx_L130_bool_binop_done:;
              if (__pyx_t_27) {
/* … */
                goto __pyx_L129;
              }

 5152:                                     # We didn't fire this timestep, so we can use the min shot heading error rad to turn toward the same target and try again on the next timestep

+5153:                                     next_target_heading_error = min_shot_heading_error_rad  # This is where we're aiming for the next timestep!

                __Pyx_INCREF(__pyx_v_min_shot_heading_error_rad);
                __pyx_v_next_target_heading_error = __pyx_v_min_shot_heading_error_rad;

+5154:                                 elif fire_this_timestep and not isinf(second_min_shot_heading_error_rad):

              __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_fire_this_timestep); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5154, __pyx_L1_error)
              if (__pyx_t_4) {
              } else {
                __pyx_t_27 = __pyx_t_4;
                goto __pyx_L132_bool_binop_done;
              }
              __pyx_t_31 = __Pyx_PyFloat_AsDouble(__pyx_v_second_min_shot_heading_error_rad); if (unlikely((__pyx_t_31 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5154, __pyx_L1_error)
              __pyx_t_4 = (!(isinf(__pyx_t_31) != 0));
              __pyx_t_27 = __pyx_t_4;
              __pyx_L132_bool_binop_done:;
              if (__pyx_t_27) {
/* … */
                goto __pyx_L129;
              }

+5155:                                     next_target_heading_error = second_min_shot_heading_error_rad  # This is where we're aiming for the next timestep!

                __Pyx_INCREF(__pyx_v_second_min_shot_heading_error_rad);
                __pyx_v_next_target_heading_error = __pyx_v_second_min_shot_heading_error_rad;

 5156:                                 else:

+5157:                                     next_target_heading_error = NAN

              /*else*/ {
                __pyx_t_18 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5157, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_v_next_target_heading_error = __pyx_t_18;
                __pyx_t_18 = 0;
              }
              __pyx_L129:;

 5158:                                 # The assumption is that the target that was hit wasn't the second smallest heading diff. THIS IS NOT TRUE IN GENERAL. This can be wrong! But whatever, it's not a big deal and probably not worth fixing/taking the extra compute to track this.

+5159:                                 if not isnan(next_target_heading_error):

              __pyx_t_31 = __Pyx_PyFloat_AsDouble(__pyx_v_next_target_heading_error); if (unlikely((__pyx_t_31 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5159, __pyx_L1_error)
              __pyx_t_27 = (!isnan(__pyx_t_31));
              if (__pyx_t_27) {
/* … */
              }

+5160:                                     min_shot_heading_error_deg = degrees(next_target_heading_error)

                __pyx_t_2 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5160, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_9))) {
                  __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9);
                  assert(__pyx_t_2);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
                  __Pyx_INCREF(__pyx_t_2);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_next_target_heading_error};
                  __pyx_t_18 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5160, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_18);
                }
                __pyx_v_min_shot_heading_error_deg = __pyx_t_18;
                __pyx_t_18 = 0;

+5161:                                     if abs(min_shot_heading_error_deg) <= DEGREES_TURNED_PER_TIMESTEP:

                __pyx_t_18 = __Pyx_PyNumber_Absolute(__pyx_v_min_shot_heading_error_deg); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5161, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DEGREES_TURNED_PER_TIMESTEP); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5161, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
                __pyx_t_2 = PyObject_RichCompare(__pyx_t_18, __pyx_t_9, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5161, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5161, __pyx_L1_error)
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                if (__pyx_t_27) {
/* … */
                  goto __pyx_L135;
                }

+5162:                                         altered_turn_command = min_shot_heading_error_deg*FPS

                  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5162, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_9 = PyNumber_Multiply(__pyx_v_min_shot_heading_error_deg, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5162, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_v_altered_turn_command = __pyx_t_9;
                  __pyx_t_9 = 0;

 5163:                                     else:

+5164:                                         altered_turn_command = SHIP_MAX_TURN_RATE*sign(min_shot_heading_error_rad)

                /*else*/ {
                  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5164, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __pyx_t_18 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5164, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __pyx_t_7 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_5))) {
                    __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_5);
                    assert(__pyx_t_18);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
                    __Pyx_INCREF(__pyx_t_18);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
                    __pyx_t_7 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_v_min_shot_heading_error_rad};
                    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5164, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_2);
                  }
                  __pyx_t_5 = PyNumber_Multiply(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5164, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_v_altered_turn_command = __pyx_t_5;
                  __pyx_t_5 = 0;
                }
                __pyx_L135:;

+5165:                                     turn_rate = altered_turn_command

                __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_altered_turn_command); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5165, __pyx_L1_error)
                __pyx_v_turn_rate = __pyx_t_32;

+5166:                                     if whole_move_sequence:

                __pyx_t_27 = (__pyx_v_whole_move_sequence != Py_None)&&(__Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence) != 0);
                if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_27 < 0))) __PYX_ERR(0, 5166, __pyx_L1_error)
                if (__pyx_t_27) {
/* … */
                }

+5167:                                         whole_move_sequence[self.future_timesteps].turn_rate = altered_turn_command

                  if (unlikely(__pyx_v_whole_move_sequence == Py_None)) {
                    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
                    __PYX_ERR(0, 5167, __pyx_L1_error)
                  }
                  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5167, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_whole_move_sequence, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5167, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  if (__Pyx_PyObject_SetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_v_altered_turn_command) < 0) __PYX_ERR(0, 5167, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+5168:                         elif self.respawn_maneuver_pass_number == 0 and (self.future_timesteps >= MANEUVER_SIM_DISALLOW_TARGETING_FOR_START_TIMESTEPS_AMOUNT or timesteps_until_can_fire == 1):

          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5168, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5168, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          if (__pyx_t_4) {
          } else {
            __pyx_t_27 = __pyx_t_4;
            goto __pyx_L137_bool_binop_done;
          }
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5168, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MANEUVER_SIM_DISALLOW_TARGETING); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5168, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_9 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5168, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5168, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (!__pyx_t_4) {
          } else {
            __pyx_t_27 = __pyx_t_4;
            goto __pyx_L137_bool_binop_done;
          }
          __pyx_t_4 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_timesteps_until_can_fire, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5168, __pyx_L1_error)
          __pyx_t_27 = __pyx_t_4;
          __pyx_L137_bool_binop_done:;
          if (__pyx_t_27) {
/* … */
          }
          __pyx_L68:;

 5169:                             # timesteps_until_can_fire is 1, 2, or 3

 5170:                             # On the next timestep, hopefully we'd be aimed at the asteroid and then the above if case will kick in and we will shoot it!

 5171:                             # This makes the shot efficiency during maneuvering a lot better because we're not only dodging, but we're also targetting and firing at the same time!

 5172:                             # If there's more timesteps to turn before we can fire, then we can still begin to turn toward the closest target

+5173:                             locked_in = False

            __pyx_v_locked_in = 0;

 5174:                             #global update_ts_multiple_count

+5175:                             asteroid_least_shot_heading_error_deg = INFINITY

            __pyx_t_9 = PyFloat_FromDouble(INFINITY); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5175, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_v_asteroid_least_shot_heading_error_deg = __pyx_t_9;
            __pyx_t_9 = 0;

+5176:                             asteroid_least_shot_heading_tolerance_deg = NAN

            __pyx_t_9 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5176, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_v_asteroid_least_shot_heading_tolerance_deg = __pyx_t_9;
            __pyx_t_9 = 0;

 5177: 

 5178:                             # Roughly predict the ship's position on the next timestep using its current heading. This isn't 100% correct but whatever, it's better than nothing.

+5179:                             ship_pred_speed = self.ship_state.speed

            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5179, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5179, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_v_ship_pred_speed = __pyx_t_5;
            __pyx_t_5 = 0;

+5180:                             drag_amount = SHIP_DRAG*DELTA_TIME

            __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5180, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5180, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_2 = PyNumber_Multiply(__pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5180, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_v_drag_amount = __pyx_t_2;
            __pyx_t_2 = 0;

+5181:                             if drag_amount > abs(ship_pred_speed):

            __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_v_ship_pred_speed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5181, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_9 = PyObject_RichCompare(__pyx_v_drag_amount, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5181, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5181, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (__pyx_t_27) {
/* … */
              goto __pyx_L140;
            }

+5182:                                 ship_pred_speed = 0.0

              __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
              __Pyx_DECREF_SET(__pyx_v_ship_pred_speed, __pyx_mstate_global->__pyx_float_0_0);

 5183:                             else:

+5184:                                 ship_pred_speed -= drag_amount*sign(ship_pred_speed)

            /*else*/ {
              __pyx_t_2 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5184, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
              __pyx_t_7 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_5))) {
                __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
                assert(__pyx_t_2);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
                __Pyx_INCREF(__pyx_t_2);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
                __pyx_t_7 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_ship_pred_speed};
                __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5184, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
              }
              __pyx_t_5 = PyNumber_Multiply(__pyx_v_drag_amount, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5184, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              __pyx_t_9 = PyNumber_InPlaceSubtract(__pyx_v_ship_pred_speed, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5184, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_DECREF_SET(__pyx_v_ship_pred_speed, __pyx_t_9);
              __pyx_t_9 = 0;
            }
            __pyx_L140:;

 5185:                             # Apply thrust

+5186:                             ship_pred_speed += min(max(-SHIP_MAX_THRUST, thrust), SHIP_MAX_THRUST)*DELTA_TIME

            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_32 = __pyx_v_thrust;
            __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_2 = PyNumber_Negative(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_18 = PyFloat_FromDouble(__pyx_t_32); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __pyx_t_1 = PyObject_RichCompare(__pyx_t_18, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (__pyx_t_27) {
              __pyx_t_1 = PyFloat_FromDouble(__pyx_t_32); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5186, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_5 = __pyx_t_1;
              __pyx_t_1 = 0;
            } else {
              __Pyx_INCREF(__pyx_t_2);
              __pyx_t_5 = __pyx_t_2;
            }
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_INCREF(__pyx_t_5);
            __pyx_t_2 = __pyx_t_5;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_1 = PyObject_RichCompare(__pyx_t_9, __pyx_t_2, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (__pyx_t_27) {
              __Pyx_INCREF(__pyx_t_9);
              __pyx_t_5 = __pyx_t_9;
            } else {
              __Pyx_INCREF(__pyx_t_2);
              __pyx_t_5 = __pyx_t_2;
            }
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_2 = PyNumber_Multiply(__pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_v_ship_pred_speed, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5186, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF_SET(__pyx_v_ship_pred_speed, __pyx_t_9);
            __pyx_t_9 = 0;

+5187:                             if ship_pred_speed > SHIP_MAX_SPEED:

            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5187, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_2 = PyObject_RichCompare(__pyx_v_ship_pred_speed, __pyx_t_9, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5187, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5187, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            if (__pyx_t_27) {
/* … */
              goto __pyx_L141;
            }

+5188:                                 ship_pred_speed = SHIP_MAX_SPEED

              __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5188, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_DECREF_SET(__pyx_v_ship_pred_speed, __pyx_t_2);
              __pyx_t_2 = 0;

+5189:                             elif ship_pred_speed < -SHIP_MAX_SPEED:

            __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5189, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_9 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5189, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_2 = PyObject_RichCompare(__pyx_v_ship_pred_speed, __pyx_t_9, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5189, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5189, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            if (__pyx_t_27) {
/* … */
            }
            __pyx_L141:;

+5190:                                 ship_pred_speed = -SHIP_MAX_SPEED

              __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5190, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_2);
              __pyx_t_9 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5190, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __Pyx_DECREF_SET(__pyx_v_ship_pred_speed, __pyx_t_9);
              __pyx_t_9 = 0;

+5191:                             rad_heading = radians(self.ship_state.heading)

            __pyx_t_2 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5191, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5191, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5191, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __pyx_t_7 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_5))) {
              __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
              assert(__pyx_t_2);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
              __Pyx_INCREF(__pyx_t_2);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
              __pyx_t_7 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_18};
              __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
              if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5191, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
            }
            __pyx_v_rad_heading = __pyx_t_9;
            __pyx_t_9 = 0;

+5192:                             ship_speed_ts = DELTA_TIME*float(timesteps_until_can_fire)*ship_pred_speed

            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5192, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            if (unlikely(__pyx_v_timesteps_until_can_fire == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "float() argument must be a string or a number, not 'NoneType'");
              __PYX_ERR(0, 5192, __pyx_L1_error)
            }
            __pyx_t_32 = PyLong_AsDouble(__pyx_v_timesteps_until_can_fire); if (unlikely(__pyx_t_32 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5192, __pyx_L1_error)
            __pyx_t_5 = PyFloat_FromDouble(__pyx_t_32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5192, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_18 = PyNumber_Multiply(__pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5192, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_5 = PyNumber_Multiply(__pyx_t_18, __pyx_v_ship_pred_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5192, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __pyx_v_ship_speed_ts = __pyx_t_5;
            __pyx_t_5 = 0;

+5193:                             ship_predicted_pos_x = self.ship_state.position[0] + ship_speed_ts*cos(rad_heading)

            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5193, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5193, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_18, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5193, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5193, __pyx_L1_error)
            __pyx_t_18 = PyFloat_FromDouble(cos(__pyx_t_32)); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5193, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __pyx_t_9 = PyNumber_Multiply(__pyx_v_ship_speed_ts, __pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5193, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __pyx_t_18 = PyNumber_Add(__pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5193, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_v_ship_predicted_pos_x = __pyx_t_18;
            __pyx_t_18 = 0;

+5194:                             ship_predicted_pos_y = self.ship_state.position[1] + ship_speed_ts*sin(rad_heading)

            __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5194, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5194, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5194, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5194, __pyx_L1_error)
            __pyx_t_9 = PyFloat_FromDouble(sin(__pyx_t_32)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5194, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_5 = PyNumber_Multiply(__pyx_v_ship_speed_ts, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5194, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_9 = PyNumber_Add(__pyx_t_18, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5194, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_v_ship_predicted_pos_y = __pyx_t_9;
            __pyx_t_9 = 0;

+5195:                             for asteroid in chain(self.game_state.asteroids, self.forecasted_asteroid_splits):

            __pyx_t_5 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_chain); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5195, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5195, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5195, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5195, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_7 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_18))) {
              __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_18);
              assert(__pyx_t_5);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18);
              __Pyx_INCREF(__pyx_t_5);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_18, __pyx__function);
              __pyx_t_7 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_1, __pyx_t_2};
              __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_18, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5195, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
            }
            if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
              __pyx_t_18 = __pyx_t_9; __Pyx_INCREF(__pyx_t_18);
              __pyx_t_19 = 0;
              __pyx_t_17 = NULL;
            } else {
              __pyx_t_19 = -1; __pyx_t_18 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5195, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_18);
              __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_18); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5195, __pyx_L1_error)
            }
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            for (;;) {
              if (likely(!__pyx_t_17)) {
                if (likely(PyList_CheckExact(__pyx_t_18))) {
                  {
                    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_18);
                    #if !CYTHON_ASSUME_SAFE_SIZE
                    if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5195, __pyx_L1_error)
                    #endif
                    if (__pyx_t_19 >= __pyx_temp) break;
                  }
                  __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_18, __pyx_t_19);
                  ++__pyx_t_19;
                } else {
                  {
                    Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_18);
                    #if !CYTHON_ASSUME_SAFE_SIZE
                    if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5195, __pyx_L1_error)
                    #endif
                    if (__pyx_t_19 >= __pyx_temp) break;
                  }
                  #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                  __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_18, __pyx_t_19));
                  #else
                  __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_18, __pyx_t_19);
                  #endif
                  ++__pyx_t_19;
                }
                if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5195, __pyx_L1_error)
              } else {
                __pyx_t_9 = __pyx_t_17(__pyx_t_18);
                if (unlikely(!__pyx_t_9)) {
                  PyObject* exc_type = PyErr_Occurred();
                  if (exc_type) {
                    if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5195, __pyx_L1_error)
                    PyErr_Clear();
                  }
                  break;
                }
              }
              __Pyx_GOTREF(__pyx_t_9);
              __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_9);
              __pyx_t_9 = 0;
/* … */
              __pyx_L142_continue:;
            }
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

 5196:                                 # Avoid shooting my size 1 asteroids that are about to get mined by my mine

+5197:                                 avoid_targeting_this_asteroid = False

              __Pyx_INCREF(Py_False);
              __Pyx_XDECREF_SET(__pyx_v_avoid_targeting_this_asteroid, Py_False);

+5198:                                 if asteroid.size == 1:

              __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5198, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
              __pyx_t_27 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5198, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              if (__pyx_t_27) {
/* … */
              }

+5199:                                     for m in self.game_state.mines:

                __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5199, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5199, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
                  __pyx_t_9 = __pyx_t_2; __Pyx_INCREF(__pyx_t_9);
                  __pyx_t_16 = 0;
                  __pyx_t_28 = NULL;
                } else {
                  __pyx_t_16 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5199, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __pyx_t_28 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 5199, __pyx_L1_error)
                }
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                for (;;) {
                  if (likely(!__pyx_t_28)) {
                    if (likely(PyList_CheckExact(__pyx_t_9))) {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5199, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_16);
                      ++__pyx_t_16;
                    } else {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5199, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                      __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_16));
                      #else
                      __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_16);
                      #endif
                      ++__pyx_t_16;
                    }
                    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5199, __pyx_L1_error)
                  } else {
                    __pyx_t_2 = __pyx_t_28(__pyx_t_9);
                    if (unlikely(!__pyx_t_2)) {
                      PyObject* exc_type = PyErr_Occurred();
                      if (exc_type) {
                        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5199, __pyx_L1_error)
                        PyErr_Clear();
                      }
                      break;
                    }
                  }
                  __Pyx_GOTREF(__pyx_t_2);
                  __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_2);
                  __pyx_t_2 = 0;
/* … */
                }
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                goto __pyx_L152_for_end;
                __pyx_L146_break:;
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                goto __pyx_L152_for_end;
                __pyx_L152_for_end:;

+5200:                                         if m.position in self.mine_positions_placed:

                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5200, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5200, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __pyx_t_27 = (__Pyx_PySequence_ContainsTF(__pyx_t_2, __pyx_t_1, Py_EQ)); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5200, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                  if (__pyx_t_27) {
/* … */
                  }

 5201:                                             # This mine is mine

 5202:                                             #project_asteroid_by_timesteps_num = round(m.remaining_time*FPS)

 5203:                                             #asteroid_when_mine_explodes = time_travel_asteroid(asteroid, project_asteroid_by_timesteps_num, self.game_state)

+5204:                                             asteroid_when_mine_explodes = time_travel_asteroid_s(asteroid, m.remaining_time, self.game_state)

                    __pyx_t_2 = NULL;
                    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_time_travel_asteroid_s); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5204, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5204, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5204, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __pyx_t_7 = 1;
                    #if CYTHON_UNPACK_METHODS
                    if (unlikely(PyMethod_Check(__pyx_t_5))) {
                      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
                      assert(__pyx_t_2);
                      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
                      __Pyx_INCREF(__pyx_t_2);
                      __Pyx_INCREF(__pyx__function);
                      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
                      __pyx_t_7 = 0;
                    }
                    #endif
                    {
                      PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_v_asteroid, __pyx_t_8, __pyx_t_6};
                      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
                      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5204, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_1);
                    }
                    __Pyx_XDECREF_SET(__pyx_v_asteroid_when_mine_explodes, __pyx_t_1);
                    __pyx_t_1 = 0;

 5205:                                             #if check_collision(asteroid_when_mine_explodes.position[0], asteroid_when_mine_explodes.position[1], asteroid_when_mine_explodes.radius, m.position[0], m.position[1], MINE_BLAST_RADIUS):

+5206:                                             delta_x = asteroid_when_mine_explodes.position[0] - m.position[0]

                    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5206, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5206, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5206, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5206, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __pyx_t_1 = PyNumber_Subtract(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5206, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_1);
                    __pyx_t_1 = 0;

+5207:                                             delta_y = asteroid_when_mine_explodes.position[1] - m.position[1]

                    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5207, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5207, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5207, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5207, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __pyx_t_1 = PyNumber_Subtract(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5207, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_1);
                    __pyx_t_1 = 0;

+5208:                                             separation = asteroid_when_mine_explodes.radius + MINE_BLAST_RADIUS

                    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid_when_mine_explodes, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5208, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5208, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_6 = PyNumber_Add(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5208, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_6);
                    __pyx_t_6 = 0;

+5209:                                             if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

                    __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    if (__pyx_t_4) {
                    } else {
                      __pyx_t_27 = __pyx_t_4;
                      goto __pyx_L149_bool_binop_done;
                    }
                    __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    if (__pyx_t_4) {
                    } else {
                      __pyx_t_27 = __pyx_t_4;
                      goto __pyx_L149_bool_binop_done;
                    }
                    __pyx_t_6 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __pyx_t_5 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_1 = PyNumber_Add(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __pyx_t_5 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_6 = PyObject_RichCompare(__pyx_t_1, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5209, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __pyx_t_27 = __pyx_t_4;
                    __pyx_L149_bool_binop_done:;
                    if (__pyx_t_27) {
/* … */
                    }

+5210:                                                 avoid_targeting_this_asteroid = True

                      __Pyx_INCREF(Py_True);
                      __Pyx_DECREF_SET(__pyx_v_avoid_targeting_this_asteroid, Py_True);

+5211:                                                 break

                      goto __pyx_L146_break;

+5212:                                 if avoid_targeting_this_asteroid:

              __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_v_avoid_targeting_this_asteroid); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5212, __pyx_L1_error)
              if (__pyx_t_27) {
/* … */
              }

+5213:                                     continue

                goto __pyx_L142_continue;

+5214:                                 if check_whether_this_is_a_new_asteroid_for_which_we_do_not_have_a_pending_shot(self.asteroids_pending_death, self.initial_timestep + self.future_timesteps + 1, self.game_state, asteroid):

              __pyx_t_6 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_check_whether_this_is_a_new_aste_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
              __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_8);
              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_2);
              __pyx_t_13 = PyNumber_Add(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_13, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __pyx_t_7 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_5))) {
                __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
                assert(__pyx_t_6);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
                __Pyx_INCREF(__pyx_t_6);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
                __pyx_t_7 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[5] = {__pyx_t_6, __pyx_t_1, __pyx_t_2, __pyx_t_13, __pyx_v_asteroid};
                __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5214, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_9);
              }
              __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5214, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              if (__pyx_t_27) {
/* … */
              }

+5215:                                     for a in unwrap_asteroid(asteroid, self.game_state.map_size[0], self.game_state.map_size[1], UNWRAP_ASTEROID_TARGET_SELECTION_TIME_HORIZON, True):

                __pyx_t_5 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_unwrap_asteroid); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_13);
                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_1);
                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_2);
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_1);
                __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_6);
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_1);
                __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_UNWRAP_ASTEROID_TARGET_SELECTION); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5215, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_6);
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_13))) {
                  __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_13);
                  assert(__pyx_t_5);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
                  __Pyx_INCREF(__pyx_t_5);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[6] = {__pyx_t_5, __pyx_v_asteroid, __pyx_t_2, __pyx_t_1, __pyx_t_6, Py_True};
                  __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_7, (6-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5215, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                }
                if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
                  __pyx_t_13 = __pyx_t_9; __Pyx_INCREF(__pyx_t_13);
                  __pyx_t_16 = 0;
                  __pyx_t_28 = NULL;
                } else {
                  __pyx_t_16 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5215, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_13);
                  __pyx_t_28 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 5215, __pyx_L1_error)
                }
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                for (;;) {
                  if (likely(!__pyx_t_28)) {
                    if (likely(PyList_CheckExact(__pyx_t_13))) {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5215, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_16);
                      ++__pyx_t_16;
                    } else {
                      {
                        Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
                        #if !CYTHON_ASSUME_SAFE_SIZE
                        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5215, __pyx_L1_error)
                        #endif
                        if (__pyx_t_16 >= __pyx_temp) break;
                      }
                      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                      __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_16));
                      #else
                      __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_16);
                      #endif
                      ++__pyx_t_16;
                    }
                    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5215, __pyx_L1_error)
                  } else {
                    __pyx_t_9 = __pyx_t_28(__pyx_t_13);
                    if (unlikely(!__pyx_t_9)) {
                      PyObject* exc_type = PyErr_Occurred();
                      if (exc_type) {
                        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5215, __pyx_L1_error)
                        PyErr_Clear();
                      }
                      break;
                    }
                  }
                  __Pyx_GOTREF(__pyx_t_9);
                  __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_9);
                  __pyx_t_9 = 0;
/* … */
                  __pyx_L155_continue:;
                }
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                goto __pyx_L172_for_end;
                __pyx_L156_break:;
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                goto __pyx_L172_for_end;
                __pyx_L172_for_end:;

+5216:                                         if locked_in:

                  if (__pyx_v_locked_in) {
/* … */
                  }

+5217:                                             break

                    goto __pyx_L156_break;

 5218:                                         #unwrapped_ast_angle = super_fast_atan2(a.position[1] - self.ship_state.position[1], a.position[0] - self.ship_state.position[0])

 5219:                                         #if abs(angle_difference_deg(degrees(unwrapped_ast_angle), self.ship_state.heading)) > MANEUVER_CONVENIENT_SHOT_CHECKER_CONE_WIDTH_ANGLE_HALF:

+5220:                                         if not heading_diff_within_threshold(ship_heading_rad, a.position[0] - self.ship_state.position[0], a.position[1] - self.ship_state.position[1], MANEUVER_CONVENIENT_SHOT_CHECKER_CONE_WIDTH_ANGLE_HALF_COSINE):

                  __pyx_t_6 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_heading_diff_within_threshold); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_8);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                  __pyx_t_8 = PyNumber_Subtract(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_8);
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_30, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                  __pyx_t_30 = PyNumber_Subtract(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MANEUVER_CONVENIENT_SHOT_CHECKER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_7 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_1))) {
                    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
                    assert(__pyx_t_6);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
                    __Pyx_INCREF(__pyx_t_6);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
                    __pyx_t_7 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[5] = {__pyx_t_6, __pyx_v_ship_heading_rad, __pyx_t_8, __pyx_t_30, __pyx_t_2};
                    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5220, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_9);
                  }
                  __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5220, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __pyx_t_4 = (!__pyx_t_27);
                  if (__pyx_t_4) {
/* … */
                  }

+5221:                                             continue

                    goto __pyx_L155_continue;

 5222:                                         # feasible, shot_heading_error_rad, shot_heading_tolerance_rad, interception_time, intercept_x, intercept_y, asteroid_dist_during_interception

+5223:                                         feasible, shot_heading_error_rad, shot_heading_tolerance_rad, interception_time, _, _, _ = calculate_interception(ship_predicted_pos_x, ship_predicted_pos_y, a.position[0], a.position[1], a.velocity[0], a.velocity[1], a.radius, self.ship_state.heading, self.game_state, timesteps_until_can_fire)

                  __pyx_t_1 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_calculate_interception); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_30, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_8);
                  __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_30, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_30, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __pyx_t_29 = __Pyx_GetItemInt(__pyx_t_30, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_29);
                  __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                  __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_30);
                  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_23);
                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5223, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __pyx_t_7 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_2))) {
                    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
                    assert(__pyx_t_1);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
                    __Pyx_INCREF(__pyx_t_1);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
                    __pyx_t_7 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[11] = {__pyx_t_1, __pyx_v_ship_predicted_pos_x, __pyx_v_ship_predicted_pos_y, __pyx_t_8, __pyx_t_6, __pyx_t_5, __pyx_t_29, __pyx_t_30, __pyx_t_23, __pyx_t_15, __pyx_v_timesteps_until_can_fire};
                    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (11-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
                    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
                    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5223, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_9);
                  }
                  if ((likely(PyTuple_CheckExact(__pyx_t_9))) || (PyList_CheckExact(__pyx_t_9))) {
                    PyObject* sequence = __pyx_t_9;
                    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
                    if (unlikely(size != 7)) {
                      if (size > 7) __Pyx_RaiseTooManyValuesError(7);
                      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                      __PYX_ERR(0, 5223, __pyx_L1_error)
                    }
                    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                    if (likely(PyTuple_CheckExact(sequence))) {
                      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
                      __Pyx_INCREF(__pyx_t_2);
                      __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1);
                      __Pyx_INCREF(__pyx_t_15);
                      __pyx_t_23 = PyTuple_GET_ITEM(sequence, 2);
                      __Pyx_INCREF(__pyx_t_23);
                      __pyx_t_30 = PyTuple_GET_ITEM(sequence, 3);
                      __Pyx_INCREF(__pyx_t_30);
                      __pyx_t_29 = PyTuple_GET_ITEM(sequence, 4);
                      __Pyx_INCREF(__pyx_t_29);
                      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 5);
                      __Pyx_INCREF(__pyx_t_5);
                      __pyx_t_6 = PyTuple_GET_ITEM(sequence, 6);
                      __Pyx_INCREF(__pyx_t_6);
                    } else {
                      __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 0);
                      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5223, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_2);
                      __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 1);
                      if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5223, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_15);
                      __pyx_t_23 = __Pyx_PyList_GetItemRef(sequence, 2);
                      if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5223, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_23);
                      __pyx_t_30 = __Pyx_PyList_GetItemRef(sequence, 3);
                      if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5223, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_30);
                      __pyx_t_29 = __Pyx_PyList_GetItemRef(sequence, 4);
                      if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5223, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_29);
                      __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 5);
                      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5223, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_5);
                      __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 6);
                      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5223, __pyx_L1_error)
                      __Pyx_XGOTREF(__pyx_t_6);
                    }
                    #else
                    {
                      Py_ssize_t i;
                      PyObject** temps[7] = {&__pyx_t_2,&__pyx_t_15,&__pyx_t_23,&__pyx_t_30,&__pyx_t_29,&__pyx_t_5,&__pyx_t_6};
                      for (i=0; i < 7; i++) {
                        PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 5223, __pyx_L1_error)
                        __Pyx_GOTREF(item);
                        *(temps[i]) = item;
                      }
                    }
                    #endif
                    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  } else {
                    Py_ssize_t index = -1;
                    PyObject** temps[7] = {&__pyx_t_2,&__pyx_t_15,&__pyx_t_23,&__pyx_t_30,&__pyx_t_29,&__pyx_t_5,&__pyx_t_6};
                    __pyx_t_8 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5223, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_8);
                    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                    __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8);
                    for (index=0; index < 7; index++) {
                      PyObject* item = __pyx_t_25(__pyx_t_8); if (unlikely(!item)) goto __pyx_L159_unpacking_failed;
                      __Pyx_GOTREF(item);
                      *(temps[index]) = item;
                    }
                    if (__Pyx_IternextUnpackEndCheck(__pyx_t_25(__pyx_t_8), 7) < 0) __PYX_ERR(0, 5223, __pyx_L1_error)
                    __pyx_t_25 = NULL;
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    goto __pyx_L160_unpacking_done;
                    __pyx_L159_unpacking_failed:;
                    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __pyx_t_25 = NULL;
                    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
                    __PYX_ERR(0, 5223, __pyx_L1_error)
                    __pyx_L160_unpacking_done:;
                  }
                  __Pyx_XDECREF_SET(__pyx_v_feasible, __pyx_t_2);
                  __pyx_t_2 = 0;
                  __Pyx_XDECREF_SET(__pyx_v_shot_heading_error_rad, __pyx_t_15);
                  __pyx_t_15 = 0;
                  __Pyx_XDECREF_SET(__pyx_v_shot_heading_tolerance_rad, __pyx_t_23);
                  __pyx_t_23 = 0;
                  __Pyx_XDECREF_SET(__pyx_v_interception_time, __pyx_t_30);
                  __pyx_t_30 = 0;
                  __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_29);
                  __pyx_t_29 = 0;
                  __Pyx_DECREF_SET(__pyx_v__, __pyx_t_5);
                  __pyx_t_5 = 0;
                  __Pyx_DECREF_SET(__pyx_v__, __pyx_t_6);
                  __pyx_t_6 = 0;

+5224:                                         if feasible and (self.asteroids_shot >= RANDOM_WALK_SCHEDULE_LENGTH or (self.random_walk_schedule[self.asteroids_shot] and shot_heading_error_rad >= 0.0) or (not self.random_walk_schedule[self.asteroids_shot] and shot_heading_error_rad <= 0.0)):

                  __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_v_feasible); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5224, __pyx_L1_error)
                  if (__pyx_t_27) {
                  } else {
                    __pyx_t_4 = __pyx_t_27;
                    goto __pyx_L162_bool_binop_done;
                  }
                  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_RANDOM_WALK_SCHEDULE_LENGTH); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __pyx_t_5 = PyObject_RichCompare(__pyx_t_9, __pyx_t_6, Py_GE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                  __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  if (!__pyx_t_27) {
                  } else {
                    __pyx_t_4 = __pyx_t_27;
                    goto __pyx_L162_bool_binop_done;
                  }
                  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_random_walk_schedule); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                  __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  if (!__pyx_t_27) {
                    goto __pyx_L165_next_or;
                  } else {
                  }
                  __pyx_t_9 = PyObject_RichCompare(__pyx_v_shot_heading_error_rad, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  if (!__pyx_t_27) {
                  } else {
                    __pyx_t_4 = __pyx_t_27;
                    goto __pyx_L162_bool_binop_done;
                  }
                  __pyx_L165_next_or:;
                  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_random_walk_schedule); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_6);
                  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                  __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __pyx_t_3 = (!__pyx_t_27);
                  if (__pyx_t_3) {
                  } else {
                    __pyx_t_4 = __pyx_t_3;
                    goto __pyx_L162_bool_binop_done;
                  }
                  __pyx_t_5 = PyObject_RichCompare(__pyx_v_shot_heading_error_rad, __pyx_mstate_global->__pyx_float_0_0, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5224, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __pyx_t_4 = __pyx_t_3;
                  __pyx_L162_bool_binop_done:;
                  if (__pyx_t_4) {
/* … */
                  }

+5225:                                             shot_heading_error_deg = degrees(shot_heading_error_rad)

                    __pyx_t_6 = NULL;
                    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5225, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_9);
                    __pyx_t_7 = 1;
                    #if CYTHON_UNPACK_METHODS
                    if (unlikely(PyMethod_Check(__pyx_t_9))) {
                      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_9);
                      assert(__pyx_t_6);
                      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
                      __Pyx_INCREF(__pyx_t_6);
                      __Pyx_INCREF(__pyx__function);
                      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
                      __pyx_t_7 = 0;
                    }
                    #endif
                    {
                      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_shot_heading_error_rad};
                      __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
                      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5225, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_5);
                    }
                    __Pyx_XDECREF_SET(__pyx_v_shot_heading_error_deg, __pyx_t_5);
                    __pyx_t_5 = 0;

+5226:                                             shot_heading_tolerance_deg = degrees(shot_heading_tolerance_rad)

                    __pyx_t_9 = NULL;
                    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_degrees); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5226, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __pyx_t_7 = 1;
                    #if CYTHON_UNPACK_METHODS
                    if (unlikely(PyMethod_Check(__pyx_t_6))) {
                      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6);
                      assert(__pyx_t_9);
                      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
                      __Pyx_INCREF(__pyx_t_9);
                      __Pyx_INCREF(__pyx__function);
                      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
                      __pyx_t_7 = 0;
                    }
                    #endif
                    {
                      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_shot_heading_tolerance_rad};
                      __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
                      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5226, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_5);
                    }
                    __Pyx_XDECREF_SET(__pyx_v_shot_heading_tolerance_deg, __pyx_t_5);
                    __pyx_t_5 = 0;

+5227:                                             if abs(shot_heading_error_deg) - shot_heading_tolerance_deg < abs(asteroid_least_shot_heading_error_deg):

                    __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_v_shot_heading_error_deg); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5227, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_6 = PyNumber_Subtract(__pyx_t_5, __pyx_v_shot_heading_tolerance_deg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5227, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_6);
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __pyx_t_5 = __Pyx_PyNumber_Absolute(__pyx_v_asteroid_least_shot_heading_error_deg); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5227, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __pyx_t_9 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5227, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5227, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                    if (__pyx_t_4) {
/* … */
                    }

+5228:                                                 asteroid_least_shot_heading_error_deg = shot_heading_error_deg

                      __Pyx_INCREF(__pyx_v_shot_heading_error_deg);
                      __Pyx_DECREF_SET(__pyx_v_asteroid_least_shot_heading_error_deg, __pyx_v_shot_heading_error_deg);

+5229:                                                 asteroid_least_shot_heading_tolerance_deg = shot_heading_tolerance_deg

                      __Pyx_INCREF(__pyx_v_shot_heading_tolerance_deg);
                      __Pyx_DECREF_SET(__pyx_v_asteroid_least_shot_heading_tolerance_deg, __pyx_v_shot_heading_tolerance_deg);

+5230:                                             assert shot_heading_tolerance_deg >= 0.0  # REMOVE_FOR_COMPETITION

                    #ifndef CYTHON_WITHOUT_ASSERTIONS
                    if (unlikely(__pyx_assertions_enabled())) {
                      __pyx_t_9 = PyObject_RichCompare(__pyx_v_shot_heading_tolerance_deg, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5230, __pyx_L1_error)
                      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5230, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                      if (unlikely(!__pyx_t_4)) {
                        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
                        __PYX_ERR(0, 5230, __pyx_L1_error)
                      }
                    }
                    #else
                    if ((1)); else __PYX_ERR(0, 5230, __pyx_L1_error)
                    #endif

+5231:                                             if abs(shot_heading_error_deg) - shot_heading_tolerance_deg <= DEGREES_TURNED_PER_TIMESTEP:

                    __pyx_t_9 = __Pyx_PyNumber_Absolute(__pyx_v_shot_heading_error_deg); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5231, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_9);
                    __pyx_t_5 = PyNumber_Subtract(__pyx_t_9, __pyx_v_shot_heading_tolerance_deg); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5231, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_5);
                    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DEGREES_TURNED_PER_TIMESTEP); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5231, __pyx_L1_error)
                    __Pyx_GOTREF(__pyx_t_9);
                    __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_9, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5231, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5231, __pyx_L1_error)
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    if (__pyx_t_4) {
/* … */
                    }

 5232:                                                 #update_ts_multiple_count += 1

+5233:                                                 locked_in = True

                      __pyx_v_locked_in = 1;

+5234:                                                 if abs(shot_heading_error_deg) <= DEGREES_TURNED_PER_TIMESTEP:

                      __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_v_shot_heading_error_deg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5234, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_6);
                      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DEGREES_TURNED_PER_TIMESTEP); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5234, __pyx_L1_error)
                      __Pyx_GOTREF(__pyx_t_9);
                      __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_9, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5234, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5234, __pyx_L1_error)
                      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                      if (__pyx_t_4) {
/* … */
                        goto __pyx_L170;
                      }

 5235:                                                     # We can turn directly to the target's center without needing the tolerance at all!

+5236:                                                     altered_turn_command = shot_heading_error_deg*FPS

                        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5236, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_5);
                        __pyx_t_9 = PyNumber_Multiply(__pyx_v_shot_heading_error_deg, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5236, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_9);
                        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                        __Pyx_XDECREF_SET(__pyx_v_altered_turn_command, __pyx_t_9);
                        __pyx_t_9 = 0;

+5237:                                                     assert abs(altered_turn_command) <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

                        #ifndef CYTHON_WITHOUT_ASSERTIONS
                        if (unlikely(__pyx_assertions_enabled())) {
                          __pyx_t_9 = __Pyx_PyNumber_Absolute(__pyx_v_altered_turn_command); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5237, __pyx_L1_error)
                          __Pyx_GOTREF(__pyx_t_9);
                          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5237, __pyx_L1_error)
                          __Pyx_GOTREF(__pyx_t_5);
                          __pyx_t_6 = PyObject_RichCompare(__pyx_t_9, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5237, __pyx_L1_error)
                          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5237, __pyx_L1_error)
                          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                          if (unlikely(!__pyx_t_4)) {
                            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
                            __PYX_ERR(0, 5237, __pyx_L1_error)
                          }
                        }
                        #else
                        if ((1)); else __PYX_ERR(0, 5237, __pyx_L1_error)
                        #endif

 5238:                                                 else:

+5239:                                                     altered_turn_command = SHIP_MAX_TURN_RATE*sign(shot_heading_error_deg)

                      /*else*/ {
                        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5239, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_6);
                        __pyx_t_9 = NULL;
                        __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5239, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_29);
                        __pyx_t_7 = 1;
                        #if CYTHON_UNPACK_METHODS
                        if (unlikely(PyMethod_Check(__pyx_t_29))) {
                          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_29);
                          assert(__pyx_t_9);
                          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
                          __Pyx_INCREF(__pyx_t_9);
                          __Pyx_INCREF(__pyx__function);
                          __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
                          __pyx_t_7 = 0;
                        }
                        #endif
                        {
                          PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_shot_heading_error_deg};
                          __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
                          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5239, __pyx_L1_error)
                          __Pyx_GOTREF(__pyx_t_5);
                        }
                        __pyx_t_29 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5239, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_29);
                        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                        __Pyx_XDECREF_SET(__pyx_v_altered_turn_command, __pyx_t_29);
                        __pyx_t_29 = 0;
                      }
                      __pyx_L170:;

+5240:                                                 turn_rate = altered_turn_command

                      __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_altered_turn_command); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5240, __pyx_L1_error)
                      __pyx_v_turn_rate = __pyx_t_32;

+5241:                                                 if whole_move_sequence:

                      __pyx_t_4 = (__pyx_v_whole_move_sequence != Py_None)&&(__Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence) != 0);
                      if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_4 < 0))) __PYX_ERR(0, 5241, __pyx_L1_error)
                      if (__pyx_t_4) {
/* … */
                      }

+5242:                                                     whole_move_sequence[self.future_timesteps].turn_rate = altered_turn_command

                        if (unlikely(__pyx_v_whole_move_sequence == Py_None)) {
                          PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
                          __PYX_ERR(0, 5242, __pyx_L1_error)
                        }
                        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5242, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_29);
                        __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_whole_move_sequence, __pyx_t_29); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5242, __pyx_L1_error)
                        __Pyx_GOTREF(__pyx_t_5);
                        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                        if (__Pyx_PyObject_SetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_v_altered_turn_command) < 0) __PYX_ERR(0, 5242, __pyx_L1_error)
                        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+5243:                                                 break

                      goto __pyx_L156_break;

+5244:                             if not locked_in:

            __pyx_t_4 = (!__pyx_v_locked_in);
            if (__pyx_t_4) {
/* … */
            }

 5245:                                 # We can't turn all the way to something, but we can begin turning that way!

+5246:                                 if not isinf(asteroid_least_shot_heading_error_deg) and not isnan(asteroid_least_shot_heading_tolerance_deg):

              __pyx_t_31 = __Pyx_PyFloat_AsDouble(__pyx_v_asteroid_least_shot_heading_error_deg); if (unlikely((__pyx_t_31 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5246, __pyx_L1_error)
              __pyx_t_3 = (!(isinf(__pyx_t_31) != 0));
              if (__pyx_t_3) {
              } else {
                __pyx_t_4 = __pyx_t_3;
                goto __pyx_L176_bool_binop_done;
              }
              __pyx_t_31 = __Pyx_PyFloat_AsDouble(__pyx_v_asteroid_least_shot_heading_tolerance_deg); if (unlikely((__pyx_t_31 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5246, __pyx_L1_error)
              __pyx_t_3 = (!isnan(__pyx_t_31));
              __pyx_t_4 = __pyx_t_3;
              __pyx_L176_bool_binop_done:;
              if (__pyx_t_4) {
/* … */
              }

+5247:                                     altered_turn_command = SHIP_MAX_TURN_RATE*sign(asteroid_least_shot_heading_error_deg)

                __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5247, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_5 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5247, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_29);
                __pyx_t_7 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_29))) {
                  __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_29);
                  assert(__pyx_t_5);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
                  __Pyx_INCREF(__pyx_t_5);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
                  __pyx_t_7 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_asteroid_least_shot_heading_error_deg};
                  __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                  if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5247, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_13);
                }
                __pyx_t_29 = PyNumber_Multiply(__pyx_t_18, __pyx_t_13); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5247, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_29);
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                __Pyx_XDECREF_SET(__pyx_v_altered_turn_command, __pyx_t_29);
                __pyx_t_29 = 0;

+5248:                                     turn_rate = altered_turn_command

                __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_altered_turn_command); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5248, __pyx_L1_error)
                __pyx_v_turn_rate = __pyx_t_32;

+5249:                                     if whole_move_sequence:

                __pyx_t_4 = (__pyx_v_whole_move_sequence != Py_None)&&(__Pyx_PyList_GET_SIZE(__pyx_v_whole_move_sequence) != 0);
                if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_4 < 0))) __PYX_ERR(0, 5249, __pyx_L1_error)
                if (__pyx_t_4) {
/* … */
                }

+5250:                                         whole_move_sequence[self.future_timesteps].turn_rate = altered_turn_command

                  if (unlikely(__pyx_v_whole_move_sequence == Py_None)) {
                    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
                    __PYX_ERR(0, 5250, __pyx_L1_error)
                  }
                  __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5250, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_29);
                  __pyx_t_13 = __Pyx_PyObject_GetItem(__pyx_v_whole_move_sequence, __pyx_t_29); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5250, __pyx_L1_error)
                  __Pyx_GOTREF(__pyx_t_13);
                  __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                  if (__Pyx_PyObject_SetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_v_altered_turn_command) < 0) __PYX_ERR(0, 5250, __pyx_L1_error)
                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 5251:                 else:

 5252:                     #print(f"FIRE IS PRESCRIBED TO BE {fire}")

+5253:                     if self.verify_maneuver_shots:

      /*else*/ {
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_verify_maneuver_shots); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5253, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5253, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (__pyx_t_4) {
/* … */
          goto __pyx_L179;
        }

+5254:                         if fire:

          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_fire); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5254, __pyx_L1_error)
          if (__pyx_t_4) {
/* … */
            goto __pyx_L180;
          }

 5255:                             #raise Exception("This code should be unreachable currently")

+5256:                             actual_asteroid_hit, timesteps_until_bullet_hit_asteroid, ship_was_safe = self.bullet_sim(None, False, 0, True, self.future_timesteps, whole_move_sequence)

            __pyx_t_29 = __pyx_v_self;
            __Pyx_INCREF(__pyx_t_29);
            __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5256, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __pyx_t_7 = 0;
            {
              PyObject *__pyx_callargs[7] = {__pyx_t_29, Py_None, Py_False, __pyx_mstate_global->__pyx_int_0, Py_True, __pyx_t_18, __pyx_v_whole_move_sequence};
              __pyx_t_13 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_bullet_sim, __pyx_callargs+__pyx_t_7, (7-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5256, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
            }
            if ((likely(PyTuple_CheckExact(__pyx_t_13))) || (PyList_CheckExact(__pyx_t_13))) {
              PyObject* sequence = __pyx_t_13;
              Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
              if (unlikely(size != 3)) {
                if (size > 3) __Pyx_RaiseTooManyValuesError(3);
                else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                __PYX_ERR(0, 5256, __pyx_L1_error)
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              if (likely(PyTuple_CheckExact(sequence))) {
                __pyx_t_18 = PyTuple_GET_ITEM(sequence, 0);
                __Pyx_INCREF(__pyx_t_18);
                __pyx_t_29 = PyTuple_GET_ITEM(sequence, 1);
                __Pyx_INCREF(__pyx_t_29);
                __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2);
                __Pyx_INCREF(__pyx_t_5);
              } else {
                __pyx_t_18 = __Pyx_PyList_GetItemRef(sequence, 0);
                if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5256, __pyx_L1_error)
                __Pyx_XGOTREF(__pyx_t_18);
                __pyx_t_29 = __Pyx_PyList_GetItemRef(sequence, 1);
                if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5256, __pyx_L1_error)
                __Pyx_XGOTREF(__pyx_t_29);
                __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 2);
                if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5256, __pyx_L1_error)
                __Pyx_XGOTREF(__pyx_t_5);
              }
              #else
              __pyx_t_18 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5256, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_18);
              __pyx_t_29 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5256, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_29);
              __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5256, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
              #endif
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            } else {
              Py_ssize_t index = -1;
              __pyx_t_6 = PyObject_GetIter(__pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5256, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_6);
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6);
              index = 0; __pyx_t_18 = __pyx_t_25(__pyx_t_6); if (unlikely(!__pyx_t_18)) goto __pyx_L181_unpacking_failed;
              __Pyx_GOTREF(__pyx_t_18);
              index = 1; __pyx_t_29 = __pyx_t_25(__pyx_t_6); if (unlikely(!__pyx_t_29)) goto __pyx_L181_unpacking_failed;
              __Pyx_GOTREF(__pyx_t_29);
              index = 2; __pyx_t_5 = __pyx_t_25(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L181_unpacking_failed;
              __Pyx_GOTREF(__pyx_t_5);
              if (__Pyx_IternextUnpackEndCheck(__pyx_t_25(__pyx_t_6), 3) < 0) __PYX_ERR(0, 5256, __pyx_L1_error)
              __pyx_t_25 = NULL;
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              goto __pyx_L182_unpacking_done;
              __pyx_L181_unpacking_failed:;
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              __pyx_t_25 = NULL;
              if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
              __PYX_ERR(0, 5256, __pyx_L1_error)
              __pyx_L182_unpacking_done:;
            }
            __pyx_v_actual_asteroid_hit = __pyx_t_18;
            __pyx_t_18 = 0;
            __pyx_v_timesteps_until_bullet_hit_asteroid = __pyx_t_29;
            __pyx_t_29 = 0;
            __pyx_v_ship_was_safe = __pyx_t_5;
            __pyx_t_5 = 0;

+5257:                             if actual_asteroid_hit is None:

            __pyx_t_4 = (__pyx_v_actual_asteroid_hit == Py_None);
            if (__pyx_t_4) {
/* … */
              goto __pyx_L183;
            }

+5258:                                 debug_print("\nWe expected to hit stuff, but it's a good thing we checked because we don't hit anything!")

              __pyx_t_5 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5258, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_29);
              __pyx_t_7 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_29))) {
                __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_29);
                assert(__pyx_t_5);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
                __Pyx_INCREF(__pyx_t_5);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
                __pyx_t_7 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_We_expected_to_hit_stuff_but_it};
                __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
                __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
                if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5258, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_13);
              }
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+5259:                                 fire_this_timestep = False

              __Pyx_INCREF(Py_False);
              __pyx_v_fire_this_timestep = Py_False;

 5260:                             else:

+5261:                                 debug_print("\nVERIFIED THE SHOT WORKS")

            /*else*/ {
              __pyx_t_29 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5261, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
              __pyx_t_7 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_5))) {
                __pyx_t_29 = PyMethod_GET_SELF(__pyx_t_5);
                assert(__pyx_t_29);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
                __Pyx_INCREF(__pyx_t_29);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
                __pyx_t_7 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[2] = {__pyx_t_29, __pyx_mstate_global->__pyx_kp_u_VERIFIED_THE_SHOT_WORKS};
                __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
                __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5261, __pyx_L1_error)
                __Pyx_GOTREF(__pyx_t_13);
              }
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+5262:                                 fire_this_timestep = True

              __Pyx_INCREF(Py_True);
              __pyx_v_fire_this_timestep = Py_True;

+5263:                                 self.asteroids_shot += 1

              __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5263, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_13, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5263, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_t_5) < 0) __PYX_ERR(0, 5263, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            }
            __pyx_L183:;

 5264:                         else:

+5265:                             fire_this_timestep = False

          /*else*/ {
            __Pyx_INCREF(Py_False);
            __pyx_v_fire_this_timestep = Py_False;
          }
          __pyx_L180:;

 5266:                     else:

+5267:                         fire_this_timestep = fire

        /*else*/ {
          __Pyx_INCREF(__pyx_v_fire);
          __pyx_v_fire_this_timestep = __pyx_v_fire;

+5268:                         if fire:

          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_fire); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5268, __pyx_L1_error)
          if (__pyx_t_4) {
/* … */
          }
        }
        __pyx_L179:;
      }
      __pyx_L54:;

+5269:                             self.asteroids_shot += 1

            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5269, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_13 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5269, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_shot, __pyx_t_13) < 0) __PYX_ERR(0, 5269, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 5270:             else:

+5271:                 fire_this_timestep = False

    /*else*/ {
      __Pyx_INCREF(Py_False);
      __pyx_v_fire_this_timestep = Py_False;
    }
    __pyx_L53:;

 5272: 

+5273:             if fire_this_timestep:

    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_fire_this_timestep); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5273, __pyx_L1_error)
    if (__pyx_t_4) {
/* … */
    }

+5274:                 self.last_timestep_fired = self.initial_timestep + self.future_timesteps

      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5274, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5274, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_29 = PyNumber_Add(__pyx_t_13, __pyx_t_5); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5274, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_29) < 0) __PYX_ERR(0, 5274, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

 5275:                 # Remove respawn cooldown if we were in it

+5276:                 self.ship_state.is_respawning = False

      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5276, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_is_respawning, Py_False) < 0) __PYX_ERR(0, 5276, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5277:                 self.respawn_timer = 0.0

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 5277, __pyx_L1_error)

 5278:                 # Create new bullets/mines

+5279:                 if self.ship_state.bullets_remaining != -1:

      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5279, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5279, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __pyx_t_4 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5279, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_4) {
/* … */
      }

+5280:                     self.ship_state.bullets_remaining -= 1

        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5280, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5280, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyLong_SubtractObjC(__pyx_t_29, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5280, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5280, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_bullets_remaining, __pyx_t_5) < 0) __PYX_ERR(0, 5280, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5281:                 rad_heading = radians(self.ship_state.heading)

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_13))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_13);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6};
        __pyx_t_29 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5281, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
      }
      __Pyx_XDECREF_SET(__pyx_v_rad_heading, __pyx_t_29);
      __pyx_t_29 = 0;

+5282:                 cos_heading = cos(rad_heading)

      __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5282, __pyx_L1_error)
      __pyx_v_cos_heading = cos(__pyx_t_32);

+5283:                 sin_heading = sin(rad_heading)

      __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5283, __pyx_L1_error)
      __pyx_v_sin_heading = sin(__pyx_t_32);

+5284:                 bullet_x = self.ship_state.position[0] + SHIP_RADIUS*cos_heading

      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5284, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5284, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __pyx_t_29 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5284, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5284, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_6 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5284, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = PyNumber_Multiply(__pyx_t_13, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5284, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = PyNumber_Add(__pyx_t_29, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5284, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_v_bullet_x = __pyx_t_6;
      __pyx_t_6 = 0;

+5285:                 bullet_y = self.ship_state.position[1] + SHIP_RADIUS*sin_heading

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_29 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __pyx_t_13 = PyNumber_Multiply(__pyx_t_5, __pyx_t_29); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __pyx_t_29 = PyNumber_Add(__pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_v_bullet_y = __pyx_t_29;
      __pyx_t_29 = 0;

 5286:                 # Make sure the bullet isn't being fired out into the void

+5287:                 if check_coordinate_bounds(self.game_state, bullet_x, bullet_y):

      __pyx_t_13 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_check_coordinate_bounds); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5287, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5287, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_13);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_13);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_13, __pyx_t_5, __pyx_v_bullet_x, __pyx_v_bullet_y};
        __pyx_t_29 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5287, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
      }
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5287, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      if (__pyx_t_4) {
/* … */
      }

+5288:                     vx = BULLET_SPEED*cos_heading

        __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5288, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_6 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5288, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_5 = PyNumber_Multiply(__pyx_t_29, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5288, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_v_vx = __pyx_t_5;
        __pyx_t_5 = 0;

+5289:                     vy = BULLET_SPEED*sin_heading

        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_BULLET_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5289, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_6 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5289, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_29 = PyNumber_Multiply(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5289, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_v_vy = __pyx_t_29;
        __pyx_t_29 = 0;

+5290:                     new_bullet = Bullet(

        __pyx_t_6 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet);
        __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Bullet); 

+5291:                         position=(bullet_x, bullet_y),

        __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5291, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_INCREF(__pyx_v_bullet_x);
        __Pyx_GIVEREF(__pyx_v_bullet_x);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_v_bullet_x) != (0)) __PYX_ERR(0, 5291, __pyx_L1_error);
        __Pyx_INCREF(__pyx_v_bullet_y);
        __Pyx_GIVEREF(__pyx_v_bullet_y);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_v_bullet_y) != (0)) __PYX_ERR(0, 5291, __pyx_L1_error);

+5292:                         velocity=(vx, vy),

        __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5292, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_INCREF(__pyx_v_vx);
        __Pyx_GIVEREF(__pyx_v_vx);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_v_vx) != (0)) __PYX_ERR(0, 5292, __pyx_L1_error);
        __Pyx_INCREF(__pyx_v_vy);
        __Pyx_GIVEREF(__pyx_v_vy);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_v_vy) != (0)) __PYX_ERR(0, 5292, __pyx_L1_error);

+5293:                         heading=self.ship_state.heading,

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5293, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5293, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5294:                         mass=BULLET_MASS,

        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_BULLET_MASS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5294, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);

+5295:                         tail_delta=(-BULLET_LENGTH*cos_heading, -BULLET_LENGTH*sin_heading)

        __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_15 = PyNumber_Negative(__pyx_t_23); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = PyFloat_FromDouble(__pyx_v_cos_heading); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_2 = PyNumber_Multiply(__pyx_t_15, __pyx_t_23); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_BULLET_LENGTH); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_15 = PyNumber_Negative(__pyx_t_23); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = PyFloat_FromDouble(__pyx_v_sin_heading); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_8 = PyNumber_Multiply(__pyx_t_15, __pyx_t_23); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5295, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_GIVEREF(__pyx_t_2);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 5295, __pyx_L1_error);
        __Pyx_GIVEREF(__pyx_t_8);
        if (__Pyx_PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 5295, __pyx_L1_error);
        __pyx_t_2 = 0;
        __pyx_t_8 = 0;
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_6, NULL};
          __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5290, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_13, __pyx_t_8, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5290, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_18, __pyx_t_8, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5290, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_heading, __pyx_t_30, __pyx_t_8, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5290, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_9, __pyx_t_8, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 5290, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_tail_delta, __pyx_t_23, __pyx_t_8, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 5290, __pyx_L1_error)
          __pyx_t_29 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5290, __pyx_L1_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_29);
        }
        __pyx_v_new_bullet = ((struct __pyx_obj_14neo_controller_Bullet *)__pyx_t_29);
        __pyx_t_29 = 0;

 5296:                     )

+5297:                     self.game_state.bullets.append(new_bullet)

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5297, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5297, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_12 = __Pyx_PyObject_Append(__pyx_t_5, ((PyObject *)__pyx_v_new_bullet)); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5297, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 5298: 

 5299:             # We can drop a mine once every 30 frames, so make sure we wait at least that long before we try dropping another one

+5300:             if self.ship_state.mines_remaining != 0 and self.last_timestep_mined <= self.initial_timestep + self.future_timesteps - MINE_COOLDOWN_TS:

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_3 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_29, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    if (__pyx_t_3) {
    } else {
      __pyx_t_4 = __pyx_t_3;
      goto __pyx_L189_bool_binop_done;
    }
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_23 = PyNumber_Add(__pyx_t_5, __pyx_t_8); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_MINE_COOLDOWN_TS); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_5 = PyNumber_Subtract(__pyx_t_23, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_29, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5300, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_4 = __pyx_t_3;
    __pyx_L189_bool_binop_done:;
    if (__pyx_t_4) {
/* … */
      goto __pyx_L188;
    }

 5301:                 # It's possible to drop a mine at this timestep. We now check whether we want to.

+5302:                 if drop_mine is None:

      __pyx_t_4 = (__pyx_v_drop_mine == Py_None);
      if (__pyx_t_4) {
/* … */
        goto __pyx_L191;
      }

 5303:                     # It's expensive to check the mine FIS every timestep, so do it periodically as the ship moves around

 5304:                     # I also artificially restrict the mines to be placed at least 3 seconds (90 frames) apart. Technically it might be optimal to place them quicker than that though.

+5305:                     if self.last_timestep_mined <= self.initial_timestep + self.future_timesteps - MINE_COOLDOWN_TS - MINE_DROP_COOLDOWN_FUDGE_TS and not self.halt_shooting and self.future_timesteps % MINE_OPPORTUNITY_CHECK_INTERVAL_TS == 0:

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_23 = PyNumber_Add(__pyx_t_5, __pyx_t_29); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_MINE_COOLDOWN_TS); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_5 = PyNumber_Subtract(__pyx_t_23, __pyx_t_29); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_MINE_DROP_COOLDOWN_FUDGE_TS); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_23 = PyNumber_Subtract(__pyx_t_5, __pyx_t_29); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = PyObject_RichCompare(__pyx_t_8, __pyx_t_23, Py_LE); __Pyx_XGOTREF(__pyx_t_29); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        if (__pyx_t_3) {
        } else {
          __pyx_t_4 = __pyx_t_3;
          goto __pyx_L193_bool_binop_done;
        }
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_27 = (!__pyx_t_3);
        if (__pyx_t_27) {
        } else {
          __pyx_t_4 = __pyx_t_27;
          goto __pyx_L193_bool_binop_done;
        }
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_MINE_OPPORTUNITY_CHECK_INTERVAL); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_8 = PyNumber_Remainder(__pyx_t_29, __pyx_t_23); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_27 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5305, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_4 = __pyx_t_27;
        __pyx_L193_bool_binop_done:;
        if (__pyx_t_4) {
/* … */
          goto __pyx_L192;
        }

+5306:                         drop_mine_this_timestep = check_mine_opportunity(self.ship_state, self.game_state, self.other_ships)  # Read only access of the ship and game states

          __pyx_t_23 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_check_mine_opportunity); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5306, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5306, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5306, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5306, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_29))) {
            __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_29);
            assert(__pyx_t_23);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
            __Pyx_INCREF(__pyx_t_23);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_23, __pyx_t_5, __pyx_t_9, __pyx_t_30};
            __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
            __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
            if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5306, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_8);
          }
          __pyx_v_drop_mine_this_timestep = __pyx_t_8;
          __pyx_t_8 = 0;

 5307:                     else:

+5308:                         drop_mine_this_timestep = False

        /*else*/ {
          __Pyx_INCREF(Py_False);
          __pyx_v_drop_mine_this_timestep = Py_False;
        }
        __pyx_L192:;

 5309: 

+5310:                     if not isinf(self.game_state.time_limit):

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5310, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5310, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_31 = __Pyx_PyFloat_AsDouble(__pyx_t_29); if (unlikely((__pyx_t_31 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5310, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_4 = (!(isinf(__pyx_t_31) != 0));
        if (__pyx_t_4) {
/* … */
        }

 5311:                         # The scenario has a time limit

+5312:                         if self.initial_timestep + self.future_timesteps + 90 > floor(FPS*self.game_state.time_limit):

          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_30 = PyNumber_Add(__pyx_t_29, __pyx_t_8); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_8 = __Pyx_PyLong_AddObjC(__pyx_t_30, __pyx_mstate_global->__pyx_int_90, 90, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __pyx_t_29 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __pyx_t_23 = PyNumber_Multiply(__pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_9))) {
            __pyx_t_29 = PyMethod_GET_SELF(__pyx_t_9);
            assert(__pyx_t_29);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
            __Pyx_INCREF(__pyx_t_29);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_29, __pyx_t_23};
            __pyx_t_30 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5312, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_30);
          }
          __pyx_t_9 = PyObject_RichCompare(__pyx_t_8, __pyx_t_30, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5312, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (__pyx_t_4) {
/* … */
          }

 5313:                             # Dropping a mine at or past this timestep is useless because the mine won't get to explode before the scenario runs out of time, so we just veto it to not drop the mine

+5314:                             drop_mine_this_timestep = False

            __Pyx_INCREF(Py_False);
            __Pyx_DECREF_SET(__pyx_v_drop_mine_this_timestep, Py_False);

 5315: 

+5316:                         if not self.halt_shooting and self.initial_timestep + self.future_timesteps + 90 == floor(FPS*self.game_state.time_limit) and count_asteroids_in_mine_blast_radius(self.game_state, self.ship_state.position[0], self.ship_state.position[1], round(MINE_FUSE_TIME*FPS)) > 0:

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_27 < 0))) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_3 = (!__pyx_t_27);
          if (__pyx_t_3) {
          } else {
            __pyx_t_4 = __pyx_t_3;
            goto __pyx_L199_bool_binop_done;
          }
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __pyx_t_8 = PyNumber_Add(__pyx_t_9, __pyx_t_30); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __pyx_t_30 = __Pyx_PyLong_AddObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_90, 90, 0, 0); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_9 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_time_limit); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __pyx_t_18 = PyNumber_Multiply(__pyx_t_29, __pyx_t_5); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_23))) {
            __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_23);
            assert(__pyx_t_9);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
            __Pyx_INCREF(__pyx_t_9);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_18};
            __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5316, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_8);
          }
          __pyx_t_23 = PyObject_RichCompare(__pyx_t_30, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_23); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_23); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          if (__pyx_t_3) {
          } else {
            __pyx_t_4 = __pyx_t_3;
            goto __pyx_L199_bool_binop_done;
          }
          __pyx_t_8 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_count_asteroids_in_mine_blast_ra); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_29, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          __pyx_t_13 = NULL;
          __Pyx_INCREF(__pyx_builtin_round);
          __pyx_t_6 = __pyx_builtin_round; 
          __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_15);
          __pyx_t_1 = PyNumber_Multiply(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
          __pyx_t_7 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_1};
            __pyx_t_29 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5316, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_29);
          }
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_30))) {
            __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_30);
            assert(__pyx_t_8);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_30);
            __Pyx_INCREF(__pyx_t_8);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_30, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[5] = {__pyx_t_8, __pyx_t_18, __pyx_t_9, __pyx_t_5, __pyx_t_29};
            __pyx_t_23 = __Pyx_PyObject_FastCall(__pyx_t_30, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
            __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
            if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5316, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_23);
          }
          __pyx_t_30 = PyObject_RichCompare(__pyx_t_23, __pyx_mstate_global->__pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_30); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5316, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __pyx_t_4 = __pyx_t_3;
          __pyx_L199_bool_binop_done:;
          if (__pyx_t_4) {
/* … */
          }

 5317:                             # This is the last possible frame to drop a mine and have it do something. Dump the mine!

+5318:                             drop_mine_this_timestep = True

            __Pyx_INCREF(Py_True);
            __Pyx_DECREF_SET(__pyx_v_drop_mine_this_timestep, Py_True);

 5319:                 else:

 5320:                     # We're prescribing a mine drop since we're replaying actions we've already simulated and we decided to place a mine the first time we simmed this action

+5321:                     drop_mine_this_timestep = drop_mine

      /*else*/ {
        __Pyx_INCREF(__pyx_v_drop_mine);
        __pyx_v_drop_mine_this_timestep = __pyx_v_drop_mine;
      }
      __pyx_L191:;

 5322: 

+5323:                 if drop_mine_this_timestep:

      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_drop_mine_this_timestep); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5323, __pyx_L1_error)
      if (__pyx_t_4) {
/* … */
      }

+5324:                     self.sim_placed_a_mine = True

        if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sim_placed_a_mine, Py_True) < 0) __PYX_ERR(0, 5324, __pyx_L1_error)

+5325:                     self.last_timestep_mined = self.initial_timestep + self.future_timesteps

        __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5325, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5325, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_29 = PyNumber_Add(__pyx_t_30, __pyx_t_23); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5325, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_29) < 0) __PYX_ERR(0, 5325, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

 5326:                     # This doesn't check whether it's valid to place a mine! It just does it!

+5327:                     self.explanation_messages.append("This is a good chance to drop a mine to hit some asteroids and even the other ship. Bombs away!")

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_explanation_messages); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5327, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_12 = __Pyx_PyObject_Append(__pyx_t_29, __pyx_mstate_global->__pyx_kp_u_This_is_a_good_chance_to_drop_a); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5327, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

 5328:                     # Remove respawn cooldown if we were in it

+5329:                     self.ship_state.is_respawning = False

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5329, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_is_respawning, Py_False) < 0) __PYX_ERR(0, 5329, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5330:                     self.respawn_timer = 0.0

        if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 5330, __pyx_L1_error)

 5331:                     # debug_print(f'BOMBS AWAY! Sim ID {self.sim_id}, future timesteps {self.future_timesteps}')

+5332:                     new_mine = Mine(

        __pyx_t_23 = NULL;
        __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Mine);
        __pyx_t_30 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Mine); 

+5333:                         position=self.ship_state.position,

        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5333, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5333, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+5334:                         mass=MINE_MASS,

        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MINE_MASS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5334, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);

+5335:                         fuse_time=MINE_FUSE_TIME,

        __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5335, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);

+5336:                         remaining_time=MINE_FUSE_TIME

        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_MINE_FUSE_TIME); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5336, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_23, NULL};
          __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5332, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_position, __pyx_t_9, __pyx_t_6, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5332, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mass, __pyx_t_5, __pyx_t_6, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5332, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fuse_time, __pyx_t_18, __pyx_t_6, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5332, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_remaining_time, __pyx_t_8, __pyx_t_6, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 5332, __pyx_L1_error)
          __pyx_t_29 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_30, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
          __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5332, __pyx_L1_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_29);
        }
        __pyx_v_new_mine = ((struct __pyx_obj_14neo_controller_Mine *)__pyx_t_29);
        __pyx_t_29 = 0;

 5337:                     )

+5338:                     self.mine_positions_placed.add(self.ship_state.position) # Track where we placed our mine

        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5338, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_30 = __pyx_t_6;
        __Pyx_INCREF(__pyx_t_30);
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5338, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5338, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_7 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_30, __pyx_t_18};
          __pyx_t_29 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_30); __pyx_t_30 = 0;
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5338, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
        }
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5339:                     self.game_state.mines.append(new_mine)

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5339, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5339, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_12 = __Pyx_PyObject_Append(__pyx_t_6, ((PyObject *)__pyx_v_new_mine)); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5339, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5340:                     self.ship_state.mines_remaining -= 1

        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5340, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5340, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_6 = __Pyx_PyLong_SubtractObjC(__pyx_t_29, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5340, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5340, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_mines_remaining, __pyx_t_6) < 0) __PYX_ERR(0, 5340, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5341:                     if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

        __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5341, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5341, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        if (__pyx_t_4) {
/* … */
        }

+5342:                         assert self.ship_state.mines_remaining >= 0  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5342, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_29);
            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_mines_remaining); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5342, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
            __pyx_t_29 = PyObject_RichCompare(__pyx_t_6, __pyx_mstate_global->__pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_29); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5342, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5342, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
            if (unlikely(!__pyx_t_4)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 5342, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 5342, __pyx_L1_error)
          #endif

 5343:             else:

+5344:                 assert drop_mine is not True  # REMOVE_FOR_COMPETITION

    /*else*/ {
      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = (__pyx_v_drop_mine != Py_True);
        if (unlikely(!__pyx_t_4)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5344, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5344, __pyx_L1_error)
      #endif

+5345:                 drop_mine_this_timestep = False

      __Pyx_INCREF(Py_False);
      __pyx_v_drop_mine_this_timestep = Py_False;
    }
    __pyx_L188:;

 5346: 

 5347:             # Update respawn timer

+5348:             if self.respawn_timer <= 0:

    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_6 = PyObject_RichCompare(__pyx_t_29, __pyx_mstate_global->__pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5348, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5348, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_4) {
/* … */
      goto __pyx_L204;
    }

+5349:                 self.respawn_timer = 0.0

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 5349, __pyx_L1_error)

 5350:             else:

+5351:                 self.respawn_timer -= DELTA_TIME

    /*else*/ {
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5351, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5351, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __pyx_t_18 = PyNumber_InPlaceSubtract(__pyx_t_6, __pyx_t_29); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5351, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_18) < 0) __PYX_ERR(0, 5351, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    }
    __pyx_L204:;

+5352:             if not self.respawn_timer:

    __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5352, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5352, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __pyx_t_3 = (!__pyx_t_4);
    if (__pyx_t_3) {
/* … */
    }

+5353:                 self.ship_state.is_respawning = False

      __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5353, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      if (__Pyx_PyObject_SetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_is_respawning, Py_False) < 0) __PYX_ERR(0, 5353, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

+5354:                 assert self.respawn_timer == 0.0  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5354, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __pyx_t_3 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_18, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5354, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        if (unlikely(!__pyx_t_3)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5354, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5354, __pyx_L1_error)
      #endif

 5355:             # Simulate ship dynamics

+5356:             drag_amount = SHIP_DRAG*DELTA_TIME

    __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5356, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5356, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_6 = PyNumber_Multiply(__pyx_t_18, __pyx_t_29); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5356, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_XDECREF_SET(__pyx_v_drag_amount, __pyx_t_6);
    __pyx_t_6 = 0;

+5357:             if drag_amount > abs(self.ship_state.speed):

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5357, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5357, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_t_29); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5357, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = PyObject_RichCompare(__pyx_v_drag_amount, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_29); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5357, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5357, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    if (__pyx_t_3) {
/* … */
      goto __pyx_L206;
    }

+5358:                 self.ship_state.speed = 0.0

      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5358, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_speed, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 5358, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

 5359:             else:

+5360:                 self.ship_state.speed -= drag_amount*sign(self.ship_state.speed)

    /*else*/ {
      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __pyx_t_18 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_30))) {
        __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_30);
        assert(__pyx_t_18);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_30);
        __Pyx_INCREF(__pyx_t_18);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_30, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_t_5};
        __pyx_t_29 = __Pyx_PyObject_FastCall(__pyx_t_30, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5360, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
      }
      __pyx_t_30 = PyNumber_Multiply(__pyx_v_drag_amount, __pyx_t_29); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __pyx_t_29 = PyNumber_InPlaceSubtract(__pyx_t_6, __pyx_t_30); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      if (__Pyx_PyObject_SetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed, __pyx_t_29) < 0) __PYX_ERR(0, 5360, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    }
    __pyx_L206:;

 5361:             # Bounds check the thrust

 5362:             # TODO: REMOVE BOUNDS CHECKS

+5363:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5363, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_30); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5363, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    if (__pyx_t_3) {
/* … */
    }

+5364:                 assert -SHIP_MAX_THRUST <= thrust <= SHIP_MAX_THRUST  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5364, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __pyx_t_29 = PyNumber_Negative(__pyx_t_30); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5364, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        __pyx_t_30 = PyFloat_FromDouble(__pyx_v_thrust); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5364, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __pyx_t_6 = PyObject_RichCompare(__pyx_t_29, __pyx_t_30, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5364, __pyx_L1_error)
        if (__Pyx_PyObject_IsTrue(__pyx_t_6)) {
          __Pyx_DECREF(__pyx_t_6);
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5364, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = PyObject_RichCompare(__pyx_t_30, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5364, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        }
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5364, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_3)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5364, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5364, __pyx_L1_error)
      #endif

 5365:             # thrust = min(max(-SHIP_MAX_THRUST, thrust), SHIP_MAX_THRUST)

 5366:             # Apply thrust

+5367:             self.ship_state.speed += thrust*DELTA_TIME

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_thrust); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_6, __pyx_t_29); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = PyNumber_InPlaceAdd(__pyx_t_30, __pyx_t_5); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_speed, __pyx_t_29) < 0) __PYX_ERR(0, 5367, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+5368:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5368, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5368, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_3) {
/* … */
    }

+5369:                 assert -SHIP_MAX_SPEED - EPS <= self.ship_state.speed <= SHIP_MAX_SPEED + EPS, f"Ship max speed OoB: {self.ship_state.speed}, the whole move sequence is {whole_move_sequence}, the ship's move sequence is {self.ship_move_sequence}"  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5369, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_29 = PyNumber_Negative(__pyx_t_5); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5369, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5369, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_30 = PyNumber_Subtract(__pyx_t_29, __pyx_t_5); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5369, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5369, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5369, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = PyObject_RichCompare(__pyx_t_30, __pyx_t_29, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5369, __pyx_L1_error)
        if (__Pyx_PyObject_IsTrue(__pyx_t_5)) {
          __Pyx_DECREF(__pyx_t_5);
          __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_18 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_18);
          __pyx_t_8 = PyNumber_Add(__pyx_t_6, __pyx_t_18); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __pyx_t_5 = PyObject_RichCompare(__pyx_t_29, __pyx_t_8, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        }
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5369, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) {
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_29, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          __pyx_t_29 = __Pyx_PyObject_FormatSimple(__pyx_v_whole_move_sequence, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_30, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __pyx_t_24[0] = __pyx_mstate_global->__pyx_kp_u_Ship_max_speed_OoB;
          __pyx_t_24[1] = __pyx_t_5;
          __pyx_t_24[2] = __pyx_mstate_global->__pyx_kp_u_the_whole_move_sequence_is;
          __pyx_t_24[3] = __pyx_t_29;
          __pyx_t_24[4] = __pyx_mstate_global->__pyx_kp_u_the_ship_s_move_sequence_is;
          __pyx_t_24[5] = __pyx_t_8;
          __pyx_t_30 = __Pyx_PyUnicode_Join(__pyx_t_24, 6, 20 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_29) + 30 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_29) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8));
          if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5369, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_30, 0, 0);
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          __PYX_ERR(0, 5369, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5369, __pyx_L1_error)
      #endif

+5370:                 if not -SHIP_MAX_SPEED - EPS <= self.ship_state.speed <= SHIP_MAX_SPEED + EPS:  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_8 = PyNumber_Negative(__pyx_t_30); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_29 = PyNumber_Subtract(__pyx_t_8, __pyx_t_30); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = PyObject_RichCompare(__pyx_t_29, __pyx_t_8, Py_LE); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5370, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_30)) {
        __Pyx_DECREF(__pyx_t_30);
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5370, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_18 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5370, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5370, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __pyx_t_30 = PyObject_RichCompare(__pyx_t_8, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5370, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      }
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_30); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5370, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_4 = (!__pyx_t_3);
      if (__pyx_t_4) {
/* … */
      }

+5371:                     print(f"WARNING IN UPDATE SIM: Ship max speed OoB: {self.ship_state.speed}, the whole move sequence is {whole_move_sequence}, the ship's move sequence is {self.ship_move_sequence}")  # REMOVE_FOR_COMPETITION

        __pyx_t_8 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_29 = __pyx_builtin_print; 
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5371, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5371, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_18, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5371, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_v_whole_move_sequence, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5371, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5371, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5371, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_24[0] = __pyx_mstate_global->__pyx_kp_u_WARNING_IN_UPDATE_SIM_Ship_max_s;
        __pyx_t_24[1] = __pyx_t_6;
        __pyx_t_24[2] = __pyx_mstate_global->__pyx_kp_u_the_whole_move_sequence_is;
        __pyx_t_24[3] = __pyx_t_18;
        __pyx_t_24[4] = __pyx_mstate_global->__pyx_kp_u_the_ship_s_move_sequence_is;
        __pyx_t_24[5] = __pyx_t_9;
        __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_24, 6, 43 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 29 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18) + 30 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_18) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5371, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_5};
          __pyx_t_30 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5371, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
        }
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;

+5372:                 if self.ship_state.speed > SHIP_MAX_SPEED:  # REMOVE_FOR_COMPETITION

      __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5372, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5372, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5372, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_5 = PyObject_RichCompare(__pyx_t_29, __pyx_t_30, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5372, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5372, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_4) {
/* … */
        goto __pyx_L210;
      }

+5373:                     self.ship_state.speed = SHIP_MAX_SPEED  # REMOVE_FOR_COMPETITION

        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5373, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5373, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        if (__Pyx_PyObject_SetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed, __pyx_t_5) < 0) __PYX_ERR(0, 5373, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;

+5374:                 elif self.ship_state.speed < -SHIP_MAX_SPEED:  # REMOVE_FOR_COMPETITION

      __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5374, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5374, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5374, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_29 = PyNumber_Negative(__pyx_t_30); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5374, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = PyObject_RichCompare(__pyx_t_5, __pyx_t_29, Py_LT); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5374, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_30); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5374, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      if (__pyx_t_4) {
/* … */
      }
      __pyx_L210:;

+5375:                     self.ship_state.speed = -SHIP_MAX_SPEED  # REMOVE_FOR_COMPETITION

        __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5375, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __pyx_t_29 = PyNumber_Negative(__pyx_t_30); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5375, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5375, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        if (__Pyx_PyObject_SetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed, __pyx_t_29) < 0) __PYX_ERR(0, 5375, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;

+5376:                 if not (-SHIP_MAX_SPEED <= self.ship_state.speed <= SHIP_MAX_SPEED):  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5376, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_29 = PyNumber_Negative(__pyx_t_30); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5376, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5376, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5376, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = PyObject_RichCompare(__pyx_t_29, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5376, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_30)) {
        __Pyx_DECREF(__pyx_t_30);
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5376, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_30 = PyObject_RichCompare(__pyx_t_5, __pyx_t_8, Py_LE); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5376, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      }
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_30); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5376, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_3 = (!__pyx_t_4);
      if (__pyx_t_3) {
/* … */
      }

+5377:                     print(self.ship_state.speed)  # REMOVE_FOR_COMPETITION

        __pyx_t_5 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_29 = __pyx_builtin_print; 
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5377, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5377, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_9};
          __pyx_t_30 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5377, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
        }
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;

+5378:                 assert -SHIP_MAX_SPEED <= self.ship_state.speed <= SHIP_MAX_SPEED  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5378, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __pyx_t_29 = PyNumber_Negative(__pyx_t_30); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5378, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5378, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_30);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5378, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        __pyx_t_30 = PyObject_RichCompare(__pyx_t_29, __pyx_t_9, Py_LE); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5378, __pyx_L1_error)
        if (__Pyx_PyObject_IsTrue(__pyx_t_30)) {
          __Pyx_DECREF(__pyx_t_30);
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5378, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_30 = PyObject_RichCompare(__pyx_t_9, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_30); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5378, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        }
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_30); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5378, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        if (unlikely(!__pyx_t_3)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5378, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5378, __pyx_L1_error)
      #endif

 5379:                 # self.ship_state.speed = min(max(-SHIP_MAX_SPEED, self.ship_state.speed), SHIP_MAX_SPEED)  # REMOVE_FOR_COMPETITION

+5380:                 if not (-SHIP_MAX_TURN_RATE <= turn_rate <= SHIP_MAX_TURN_RATE):  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5380, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_9 = PyNumber_Negative(__pyx_t_30); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5380, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_30 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5380, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_30);
      __pyx_t_29 = PyObject_RichCompare(__pyx_t_9, __pyx_t_30, Py_LE); __Pyx_XGOTREF(__pyx_t_29); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5380, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_29)) {
        __Pyx_DECREF(__pyx_t_29);
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5380, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_29 = PyObject_RichCompare(__pyx_t_30, __pyx_t_5, Py_LE); __Pyx_XGOTREF(__pyx_t_29); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5380, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5380, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      __pyx_t_4 = (!__pyx_t_3);
      if (__pyx_t_4) {
/* … */
      }

+5381:                     print(turn_rate)  # REMOVE_FOR_COMPETITION

        __pyx_t_30 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_9 = __pyx_builtin_print; 
        __pyx_t_5 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5381, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_30, __pyx_t_5};
          __pyx_t_29 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_30); __pyx_t_30 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5381, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
        }
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5382:                 assert -SHIP_MAX_TURN_RATE <= turn_rate <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5382, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_9 = PyNumber_Negative(__pyx_t_29); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5382, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5382, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_5 = PyObject_RichCompare(__pyx_t_9, __pyx_t_29, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5382, __pyx_L1_error)
        if (__Pyx_PyObject_IsTrue(__pyx_t_5)) {
          __Pyx_DECREF(__pyx_t_5);
          __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5382, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __pyx_t_5 = PyObject_RichCompare(__pyx_t_29, __pyx_t_30, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5382, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
        }
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5382, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_4)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5382, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5382, __pyx_L1_error)
      #endif

 5383:             # turn_rate = min(max(-SHIP_MAX_TURN_RATE, turn_rate), SHIP_MAX_TURN_RATE)

 5384:             # Update the angle based on turning rate

+5385:             self.ship_state.heading += turn_rate*DELTA_TIME

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_30 = PyNumber_Multiply(__pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_t_29, __pyx_t_30); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_heading, __pyx_t_9) < 0) __PYX_ERR(0, 5385, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;

 5386:             # Keep the angle within (0, 360)

+5387:             self.ship_state.heading %= 360.0

    __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __pyx_t_30 = __Pyx_PyFloat_RemainderObjC(__pyx_t_9, __pyx_mstate_global->__pyx_float_360_0, 360.0, 1, 0); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_heading, __pyx_t_30) < 0) __PYX_ERR(0, 5387, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5388:             # Use speed magnitude to get velocity vector

+5389:             rad_heading = radians(self.ship_state.heading)

    __pyx_t_30 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_radians); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_29))) {
      __pyx_t_30 = PyMethod_GET_SELF(__pyx_t_29);
      assert(__pyx_t_30);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
      __Pyx_INCREF(__pyx_t_30);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_30, __pyx_t_8};
      __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_30); __pyx_t_30 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __Pyx_XDECREF_SET(__pyx_v_rad_heading, __pyx_t_9);
    __pyx_t_9 = 0;

+5390:             self.ship_state.velocity = (cos(rad_heading)*self.ship_state.speed, sin(rad_heading)*self.ship_state.speed)

    __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5390, __pyx_L1_error)
    __pyx_t_9 = PyFloat_FromDouble(cos(__pyx_t_32)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = PyNumber_Multiply(__pyx_t_9, __pyx_t_8); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_32 = __Pyx_PyFloat_AsDouble(__pyx_v_rad_heading); if (unlikely((__pyx_t_32 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5390, __pyx_L1_error)
    __pyx_t_8 = PyFloat_FromDouble(sin(__pyx_t_32)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyNumber_Multiply(__pyx_t_8, __pyx_t_30); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __pyx_t_30 = PyTuple_New(2); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_GIVEREF(__pyx_t_29);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_30, 0, __pyx_t_29) != (0)) __PYX_ERR(0, 5390, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_9);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_30, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 5390, __pyx_L1_error);
    __pyx_t_29 = 0;
    __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_velocity, __pyx_t_30) < 0) __PYX_ERR(0, 5390, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5391:             # Update the position based off the velocities

 5392:             # Do the wrap in the same operation

+5393:             self.ship_state.position = ((self.ship_state.position[0] + self.ship_state.velocity[0]*DELTA_TIME) % self.game_state.map_size[0], (self.ship_state.position[1] + self.ship_state.velocity[1]*DELTA_TIME) % self.game_state.map_size[1])

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_30, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __pyx_t_30 = __Pyx_GetItemInt(__pyx_t_29, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_8 = PyNumber_Multiply(__pyx_t_30, __pyx_t_29); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = PyNumber_Add(__pyx_t_9, __pyx_t_8); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyNumber_Remainder(__pyx_t_29, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_29, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = __Pyx_GetItemInt(__pyx_t_30, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_29, __pyx_t_30); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __pyx_t_30 = PyNumber_Add(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_map_size); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = PyNumber_Remainder(__pyx_t_30, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GIVEREF(__pyx_t_9);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_9) != (0)) __PYX_ERR(0, 5393, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_8);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 5393, __pyx_L1_error);
    __pyx_t_9 = 0;
    __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_position, __pyx_t_5) < 0) __PYX_ERR(0, 5393, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 5394: 

 5395:         # Check bullet/asteroid collisions

+5396:         bullet_remove_idxs = []

  __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF_SET(__pyx_v_bullet_remove_idxs, ((PyObject*)__pyx_t_8));
  __pyx_t_8 = 0;

+5397:         for b_idx, b in enumerate(self.game_state.bullets):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_8 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
    __pyx_t_5 = __pyx_t_9; __Pyx_INCREF(__pyx_t_5);
    __pyx_t_19 = 0;
    __pyx_t_17 = NULL;
  } else {
    __pyx_t_19 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5397, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5397, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  for (;;) {
    if (likely(!__pyx_t_17)) {
      if (likely(PyList_CheckExact(__pyx_t_5))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5397, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_19);
        ++__pyx_t_19;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5397, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_19));
        #else
        __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_19);
        #endif
        ++__pyx_t_19;
      }
      if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5397, __pyx_L1_error)
    } else {
      __pyx_t_9 = __pyx_t_17(__pyx_t_5);
      if (unlikely(!__pyx_t_9)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5397, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_9);
    __pyx_t_9 = 0;
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_XDECREF_SET(__pyx_v_b_idx, __pyx_t_8);
    __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5397, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8);
    __pyx_t_8 = __pyx_t_9;
    __pyx_t_9 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+5398:             b_tail = (b.position[0] + b.tail_delta[0], b.position[1] + b.tail_delta[1])

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_30 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_tail_delta); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_29 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyNumber_Add(__pyx_t_30, __pyx_t_29); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_30 = __Pyx_GetItemInt(__pyx_t_29, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_30);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_tail_delta); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_18 = __Pyx_GetItemInt(__pyx_t_29, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __pyx_t_29 = PyNumber_Add(__pyx_t_30, __pyx_t_18); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5398, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __Pyx_GIVEREF(__pyx_t_9);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_9) != (0)) __PYX_ERR(0, 5398, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_29);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_29) != (0)) __PYX_ERR(0, 5398, __pyx_L1_error);
    __pyx_t_9 = 0;
    __pyx_t_29 = 0;
    __Pyx_XDECREF_SET(__pyx_v_b_tail, ((PyObject*)__pyx_t_18));
    __pyx_t_18 = 0;

+5399:             for a_idx, a in enumerate(self.game_state.asteroids):

    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_t_18 = __pyx_mstate_global->__pyx_int_0;
    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5399, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5399, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
      __pyx_t_29 = __pyx_t_9; __Pyx_INCREF(__pyx_t_29);
      __pyx_t_16 = 0;
      __pyx_t_28 = NULL;
    } else {
      __pyx_t_16 = -1; __pyx_t_29 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5399, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __pyx_t_28 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_29); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 5399, __pyx_L1_error)
    }
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    for (;;) {
      if (likely(!__pyx_t_28)) {
        if (likely(PyList_CheckExact(__pyx_t_29))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_29);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5399, __pyx_L1_error)
            #endif
            if (__pyx_t_16 >= __pyx_temp) break;
          }
          __pyx_t_9 = __Pyx_PyList_GetItemRef(__pyx_t_29, __pyx_t_16);
          ++__pyx_t_16;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_29);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5399, __pyx_L1_error)
            #endif
            if (__pyx_t_16 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_29, __pyx_t_16));
          #else
          __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_29, __pyx_t_16);
          #endif
          ++__pyx_t_16;
        }
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5399, __pyx_L1_error)
      } else {
        __pyx_t_9 = __pyx_t_28(__pyx_t_29);
        if (unlikely(!__pyx_t_9)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5399, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_9);
      __pyx_t_9 = 0;
      __Pyx_INCREF(__pyx_t_18);
      __Pyx_XDECREF_SET(__pyx_v_a_idx, __pyx_t_18);
      __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_t_18, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5399, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_18);
      __pyx_t_18 = __pyx_t_9;
      __pyx_t_9 = 0;
/* … */
      __pyx_L215_continue:;
    }
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    goto __pyx_L220_for_end;
    __pyx_L216_break:;
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    goto __pyx_L220_for_end;
    __pyx_L220_for_end:;
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

+5400:                 if a_idx in asteroid_remove_idxs:

      __pyx_t_4 = (__Pyx_PySet_ContainsTF(__pyx_v_a_idx, __pyx_v_asteroid_remove_idxs, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5400, __pyx_L1_error)
      if (__pyx_t_4) {
/* … */
      }

+5401:                     continue

        goto __pyx_L215_continue;

 5402:                 # If collision occurs

+5403:                 if asteroid_bullet_collision(b.position, b_tail, a.position, a.radius):

      __pyx_t_30 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_asteroid_bullet_collision); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5403, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5403, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5403, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5403, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_30 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_30);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_30);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[5] = {__pyx_t_30, __pyx_t_23, __pyx_v_b_tail, __pyx_t_1, __pyx_t_13};
        __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_30); __pyx_t_30 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5403, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5403, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (__pyx_t_4) {
/* … */
      }

 5404:                     # Mark bullet for removal

+5405:                     bullet_remove_idxs.append(b_idx)

        __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_bullet_remove_idxs, __pyx_v_b_idx); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5405, __pyx_L1_error)

 5406:                     # Create asteroid splits and mark it for removal

+5407:                     if a.size != 1:

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5407, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_4 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5407, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (__pyx_t_4) {
/* … */
        }

+5408:                         self.game_state.asteroids.extend(forecast_instantaneous_asteroid_bullet_splits_from_velocity(a, b.velocity, self.game_state))

          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5408, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5408, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_6 = __pyx_t_1;
          __Pyx_INCREF(__pyx_t_6);
          __pyx_t_23 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_forecast_instantaneous_asteroid); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5408, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_30);
          __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5408, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_15);
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5408, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_7 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_30))) {
            __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_30);
            assert(__pyx_t_23);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_30);
            __Pyx_INCREF(__pyx_t_23);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_30, __pyx__function);
            __pyx_t_7 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_23, __pyx_v_a, __pyx_t_15, __pyx_t_2};
            __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_30, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
            if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5408, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
          }
          __pyx_t_7 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_13};
            __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5408, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
          }
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5409:                     asteroid_remove_idxs.add(a_idx)

        __pyx_t_12 = PySet_Add(__pyx_v_asteroid_remove_idxs, __pyx_v_a_idx); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5409, __pyx_L1_error)

 5410:                     # Stop checking this bullet

+5411:                     break

        goto __pyx_L216_break;

 5412:         # Cull bullets and asteroids that are marked for removal

+5413:         if bullet_remove_idxs:

  __pyx_t_4 = (__Pyx_PyList_GET_SIZE(__pyx_v_bullet_remove_idxs) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_4 < 0))) __PYX_ERR(0, 5413, __pyx_L1_error)
  if (__pyx_t_4) {
/* … */
  }

+5414:             self.game_state.bullets = [bullet for idx, bullet in enumerate(self.game_state.bullets) if idx not in bullet_remove_idxs]

    { /* enter inner scope */
      __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5414, __pyx_L225_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5414, __pyx_L225_error)
      __Pyx_GOTREF(__pyx_t_18);
      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5414, __pyx_L225_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      if (likely(PyList_CheckExact(__pyx_t_29)) || PyTuple_CheckExact(__pyx_t_29)) {
        __pyx_t_18 = __pyx_t_29; __Pyx_INCREF(__pyx_t_18);
        __pyx_t_19 = 0;
        __pyx_t_17 = NULL;
      } else {
        __pyx_t_19 = -1; __pyx_t_18 = PyObject_GetIter(__pyx_t_29); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5414, __pyx_L225_error)
        __Pyx_GOTREF(__pyx_t_18);
        __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_18); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5414, __pyx_L225_error)
      }
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      for (;;) {
        if (likely(!__pyx_t_17)) {
          if (likely(PyList_CheckExact(__pyx_t_18))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_18);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5414, __pyx_L225_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            __pyx_t_29 = __Pyx_PyList_GetItemRef(__pyx_t_18, __pyx_t_19);
            ++__pyx_t_19;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_18);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5414, __pyx_L225_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_29 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_18, __pyx_t_19));
            #else
            __pyx_t_29 = __Pyx_PySequence_ITEM(__pyx_t_18, __pyx_t_19);
            #endif
            ++__pyx_t_19;
          }
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5414, __pyx_L225_error)
        } else {
          __pyx_t_29 = __pyx_t_17(__pyx_t_18);
          if (unlikely(!__pyx_t_29)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5414, __pyx_L225_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_XDECREF_SET(__pyx_9genexpr49__pyx_v_bullet, __pyx_t_29);
        __pyx_t_29 = 0;
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_XDECREF_SET(__pyx_9genexpr49__pyx_v_idx, __pyx_t_5);
        __pyx_t_29 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5414, __pyx_L225_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_5);
        __pyx_t_5 = __pyx_t_29;
        __pyx_t_29 = 0;
        __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_9genexpr49__pyx_v_idx, __pyx_v_bullet_remove_idxs, Py_NE)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5414, __pyx_L225_error)
        if (__pyx_t_4) {
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_8, (PyObject*)__pyx_9genexpr49__pyx_v_bullet))) __PYX_ERR(0, 5414, __pyx_L225_error)
        }
      }
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_9genexpr49__pyx_v_bullet); __pyx_9genexpr49__pyx_v_bullet = 0;
      __Pyx_XDECREF(__pyx_9genexpr49__pyx_v_idx); __pyx_9genexpr49__pyx_v_idx = 0;
      goto __pyx_L230_exit_scope;
      __pyx_L225_error:;
      __Pyx_XDECREF(__pyx_9genexpr49__pyx_v_bullet); __pyx_9genexpr49__pyx_v_bullet = 0;
      __Pyx_XDECREF(__pyx_9genexpr49__pyx_v_idx); __pyx_9genexpr49__pyx_v_idx = 0;
      goto __pyx_L1_error;
      __pyx_L230_exit_scope:;
    } /* exit inner scope */
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5414, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_8) < 0) __PYX_ERR(0, 5414, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+5415:         if not wait_out_mines:

  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_wait_out_mines); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5415, __pyx_L1_error)
  __pyx_t_3 = (!__pyx_t_4);
  if (__pyx_t_3) {
/* … */
  }

+5416:             self.ship_move_sequence.append(Action(timestep=self.initial_timestep + self.future_timesteps, thrust=thrust, turn_rate=turn_rate, fire=fire_this_timestep, drop_mine=drop_mine_this_timestep))

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_18 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
    __pyx_t_29 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_13 = PyNumber_Add(__pyx_t_9, __pyx_t_1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_thrust); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (unlikely(!__pyx_v_fire_this_timestep)) { __Pyx_RaiseUnboundLocalError("fire_this_timestep"); __PYX_ERR(0, 5416, __pyx_L1_error) }
    if (unlikely(!__pyx_v_drop_mine_this_timestep)) { __Pyx_RaiseUnboundLocalError("drop_mine_this_timestep"); __PYX_ERR(0, 5416, __pyx_L1_error) }
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_18, NULL};
      __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5416, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_13, __pyx_t_6, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5416, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_t_1, __pyx_t_6, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5416, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_t_9, __pyx_t_6, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5416, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, __pyx_v_fire_this_timestep, __pyx_t_6, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 5416, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_drop_mine, __pyx_v_drop_mine_this_timestep, __pyx_t_6, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 5416, __pyx_L1_error)
      __pyx_t_8 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_29, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
      __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5416, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_8);
    }
    __pyx_t_12 = __Pyx_PyObject_Append(__pyx_t_5, ((PyObject *)__pyx_t_8)); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5416, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF((PyObject *)__pyx_t_8); __pyx_t_8 = 0;

 5417: 

 5418:         # Check mine/asteroid and mine/ship collisions

+5419:         mine_remove_idxs: list[int] = []

  __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5419, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_v_mine_remove_idxs = ((PyObject*)__pyx_t_8);
  __pyx_t_8 = 0;

 5420:         # asteroid_remove_idxs = set() # Use a set, since this is the only case where we may have many asteroids removed at once

+5421:         new_asteroids: list[Asteroid] = []

  __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_v_new_asteroids = ((PyObject*)__pyx_t_8);
  __pyx_t_8 = 0;

+5422:         for idx_mine, mine in enumerate(self.game_state.mines):

  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
  __pyx_t_8 = __pyx_mstate_global->__pyx_int_0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_29);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (likely(PyList_CheckExact(__pyx_t_29)) || PyTuple_CheckExact(__pyx_t_29)) {
    __pyx_t_5 = __pyx_t_29; __Pyx_INCREF(__pyx_t_5);
    __pyx_t_19 = 0;
    __pyx_t_17 = NULL;
  } else {
    __pyx_t_19 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_29); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5422, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5422, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
  for (;;) {
    if (likely(!__pyx_t_17)) {
      if (likely(PyList_CheckExact(__pyx_t_5))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5422, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        __pyx_t_29 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_19);
        ++__pyx_t_19;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5422, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_29 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_19));
        #else
        __pyx_t_29 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_19);
        #endif
        ++__pyx_t_19;
      }
      if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5422, __pyx_L1_error)
    } else {
      __pyx_t_29 = __pyx_t_17(__pyx_t_5);
      if (unlikely(!__pyx_t_29)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5422, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_XDECREF_SET(__pyx_v_mine, __pyx_t_29);
    __pyx_t_29 = 0;
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_XDECREF_SET(__pyx_v_idx_mine, __pyx_t_8);
    __pyx_t_29 = __Pyx_PyLong_AddObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5422, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __Pyx_DECREF(__pyx_t_8);
    __pyx_t_8 = __pyx_t_29;
    __pyx_t_29 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+5423:             if mine.remaining_time < EPS:

    __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_remaining_time); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5423, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_29);
    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5423, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_9 = PyObject_RichCompare(__pyx_t_29, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5423, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5423, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_3) {
/* … */
    }

 5424:                 # Mine is detonating

+5425:                 mine_remove_idxs.append(idx_mine)

      __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_mine_remove_idxs, __pyx_v_idx_mine); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5425, __pyx_L1_error)

+5426:                 for a_idx, asteroid in enumerate(self.game_state.asteroids):

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_9 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5426, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5426, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (likely(PyList_CheckExact(__pyx_t_29)) || PyTuple_CheckExact(__pyx_t_29)) {
        __pyx_t_6 = __pyx_t_29; __Pyx_INCREF(__pyx_t_6);
        __pyx_t_16 = 0;
        __pyx_t_28 = NULL;
      } else {
        __pyx_t_16 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_29); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5426, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_28 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 5426, __pyx_L1_error)
      }
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      for (;;) {
        if (likely(!__pyx_t_28)) {
          if (likely(PyList_CheckExact(__pyx_t_6))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5426, __pyx_L1_error)
              #endif
              if (__pyx_t_16 >= __pyx_temp) break;
            }
            __pyx_t_29 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_16);
            ++__pyx_t_16;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5426, __pyx_L1_error)
              #endif
              if (__pyx_t_16 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_29 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_16));
            #else
            __pyx_t_29 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_16);
            #endif
            ++__pyx_t_16;
          }
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5426, __pyx_L1_error)
        } else {
          __pyx_t_29 = __pyx_t_28(__pyx_t_6);
          if (unlikely(!__pyx_t_29)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5426, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_29);
        __pyx_t_29 = 0;
        __Pyx_INCREF(__pyx_t_9);
        __Pyx_XDECREF_SET(__pyx_v_a_idx, __pyx_t_9);
        __pyx_t_29 = __Pyx_PyLong_AddObjC(__pyx_t_9, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5426, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_9);
        __pyx_t_9 = __pyx_t_29;
        __pyx_t_29 = 0;
/* … */
        __pyx_L235_continue:;
      }
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5427:                     if a_idx in asteroid_remove_idxs:

        __pyx_t_3 = (__Pyx_PySet_ContainsTF(__pyx_v_a_idx, __pyx_v_asteroid_remove_idxs, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5427, __pyx_L1_error)
        if (__pyx_t_3) {
/* … */
        }

+5428:                         continue

          goto __pyx_L235_continue;

 5429:                     #if check_collision(asteroid.position[0], asteroid.position[1], asteroid.radius, mine.position[0], mine.position[1], MINE_BLAST_RADIUS):

+5430:                     delta_x = asteroid.position[0] - mine.position[0]

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5430, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_29, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5430, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5430, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_29, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5430, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = PyNumber_Subtract(__pyx_t_1, __pyx_t_13); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5430, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_29);
        __pyx_t_29 = 0;

+5431:                     delta_y = asteroid.position[1] - mine.position[1]

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_29, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_29, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = PyNumber_Subtract(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5431, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_29);
        __pyx_t_29 = 0;

+5432:                     separation = asteroid.radius + MINE_BLAST_RADIUS

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5432, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5432, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_13 = PyNumber_Add(__pyx_t_29, __pyx_t_1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5432, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_13);
        __pyx_t_13 = 0;

+5433:                     if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

        __pyx_t_13 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_1 = PyObject_RichCompare(__pyx_t_13, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (__pyx_t_4) {
        } else {
          __pyx_t_3 = __pyx_t_4;
          goto __pyx_L239_bool_binop_done;
        }
        __pyx_t_1 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (__pyx_t_4) {
        } else {
          __pyx_t_3 = __pyx_t_4;
          goto __pyx_L239_bool_binop_done;
        }
        __pyx_t_13 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_1 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_29 = PyNumber_Add(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_13 = PyObject_RichCompare(__pyx_t_29, __pyx_t_1, Py_LE); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5433, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_3 = __pyx_t_4;
        __pyx_L239_bool_binop_done:;
        if (__pyx_t_3) {
/* … */
        }

+5434:                         if asteroid.size != 1:

          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5434, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_3 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_13, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5434, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          if (__pyx_t_3) {
/* … */
          }

+5435:                             new_asteroids.extend(forecast_asteroid_mine_instantaneous_splits(asteroid, mine, self.game_state))

            __pyx_t_1 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_mine_instantan); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5435, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_29);
            __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5435, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
            __pyx_t_7 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_29))) {
              __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_29);
              assert(__pyx_t_1);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_29);
              __Pyx_INCREF(__pyx_t_1);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_29, __pyx__function);
              __pyx_t_7 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_1, __pyx_v_asteroid, __pyx_v_mine, __pyx_t_18};
              __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_29, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
              if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5435, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
            }
            __pyx_t_12 = __Pyx_PyList_Extend(__pyx_v_new_asteroids, __pyx_t_13); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5435, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+5436:                         asteroid_remove_idxs.add(a_idx)

          __pyx_t_12 = PySet_Add(__pyx_v_asteroid_remove_idxs, __pyx_v_a_idx); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5436, __pyx_L1_error)

+5437:                 if not wait_out_mines:

      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_wait_out_mines); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5437, __pyx_L1_error)
      __pyx_t_4 = (!__pyx_t_3);
      if (__pyx_t_4) {
/* … */
      }

+5438:                     if not self.ship_state.is_respawning:

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5438, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5438, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5438, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_3 = (!__pyx_t_4);
        if (__pyx_t_3) {
/* … */
          goto __pyx_L245;
        }

 5439:                         #if check_collision(self.ship_state.position[0], self.ship_state.position[1], SHIP_RADIUS, mine.position[0], mine.position[1], MINE_BLAST_RADIUS):

+5440:                         delta_x = self.ship_state.position[0] - mine.position[0]

          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5440, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5440, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5440, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5440, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5440, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = PyNumber_Subtract(__pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5440, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_9);
          __pyx_t_9 = 0;

+5441:                         delta_y = self.ship_state.position[1] - mine.position[1]

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_13, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_13, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = PyNumber_Subtract(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5441, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_13);
          __pyx_t_13 = 0;

+5442:                         separation = SHIP_RADIUS + MINE_BLAST_RADIUS

          __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = PyNumber_Add(__pyx_t_13, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5442, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_9);
          __pyx_t_9 = 0;

+5443:                         if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

          __pyx_t_9 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_6 = PyObject_RichCompare(__pyx_t_9, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (__pyx_t_4) {
          } else {
            __pyx_t_3 = __pyx_t_4;
            goto __pyx_L247_bool_binop_done;
          }
          __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = PyObject_RichCompare(__pyx_t_6, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (__pyx_t_4) {
          } else {
            __pyx_t_3 = __pyx_t_4;
            goto __pyx_L247_bool_binop_done;
          }
          __pyx_t_9 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_6 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_13 = PyNumber_Add(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_6 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = PyObject_RichCompare(__pyx_t_13, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5443, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_3 = __pyx_t_4;
          __pyx_L247_bool_binop_done:;
          if (__pyx_t_3) {
/* … */
          }

 5444:                             # Ship got hit by mine, RIP

 5445:                             #print(f"Ship got hit by mine in sim, RIP and the ship respawn state is {self.ship_state.is_respawning} with the respawn timer at {self.respawn_timer}")

+5446:                             return_value = False

            __Pyx_INCREF(Py_False);
            __Pyx_DECREF_SET(__pyx_v_return_value, Py_False);

+5447:                             self.ship_crashed = True

            if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_crashed, Py_True) < 0) __PYX_ERR(0, 5447, __pyx_L1_error)

+5448:                             self.ship_state.lives_remaining -= 1

            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5448, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5448, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_9 = __Pyx_PyLong_SubtractObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5448, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5448, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            if (__Pyx_PyObject_SetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_lives_remaining, __pyx_t_9) < 0) __PYX_ERR(0, 5448, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5449:                             self.ship_state.is_respawning = True

            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5449, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            if (__Pyx_PyObject_SetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_is_respawning, Py_True) < 0) __PYX_ERR(0, 5449, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5450:                             self.ship_state.speed = 0.0

            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5450, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            if (__Pyx_PyObject_SetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 5450, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5451:                             self.ship_state.velocity = (0.0, 0.0)

            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5451, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            if (__Pyx_PyObject_SetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_tuple[0]) < 0) __PYX_ERR(0, 5451, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5452:                             self.respawn_timer = 3.0

            if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_mstate_global->__pyx_float_3_0) < 0) __PYX_ERR(0, 5452, __pyx_L1_error)

+5453:                     elif self.respawn_maneuver_pass_number == 1:

        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5453, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5453, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (__pyx_t_3) {
/* … */
        }
        __pyx_L245:;

 5454:                         # Record the last timestep getting hit by a mine

+5455:                         delta_x = self.ship_state.position[0] - mine.position[0]

          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5455, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5455, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5455, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5455, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5455, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = PyNumber_Subtract(__pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5455, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_9);
          __pyx_t_9 = 0;

+5456:                         delta_y = self.ship_state.position[1] - mine.position[1]

          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_13, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_mine, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_13, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = PyNumber_Subtract(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5456, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_13);
          __pyx_t_13 = 0;

+5457:                         separation = SHIP_RADIUS + MINE_BLAST_RADIUS

          __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5457, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_MINE_BLAST_RADIUS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5457, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = PyNumber_Add(__pyx_t_13, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5457, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_9);
          __pyx_t_9 = 0;

+5458:                         if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

          __pyx_t_9 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_6 = PyObject_RichCompare(__pyx_t_9, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (__pyx_t_4) {
          } else {
            __pyx_t_3 = __pyx_t_4;
            goto __pyx_L251_bool_binop_done;
          }
          __pyx_t_6 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = PyObject_RichCompare(__pyx_t_6, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (__pyx_t_4) {
          } else {
            __pyx_t_3 = __pyx_t_4;
            goto __pyx_L251_bool_binop_done;
          }
          __pyx_t_9 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_6 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_13 = PyNumber_Add(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_6 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_9 = PyObject_RichCompare(__pyx_t_13, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5458, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_3 = __pyx_t_4;
          __pyx_L251_bool_binop_done:;
          if (__pyx_t_3) {
/* … */
          }

+5459:                             self.last_timestep_colliding = self.initial_timestep + self.future_timesteps

            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5459, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5459, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
            __pyx_t_13 = PyNumber_Add(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5459, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding, __pyx_t_13) < 0) __PYX_ERR(0, 5459, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+5460:         if mine_remove_idxs:

  __pyx_t_3 = (__Pyx_PyList_GET_SIZE(__pyx_v_mine_remove_idxs) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_3 < 0))) __PYX_ERR(0, 5460, __pyx_L1_error)
  if (__pyx_t_3) {
/* … */
  }

+5461:             self.game_state.mines = [mine for idx, mine in enumerate(self.game_state.mines) if idx not in mine_remove_idxs]

    { /* enter inner scope */
      __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5461, __pyx_L258_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5461, __pyx_L258_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5461, __pyx_L258_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) {
        __pyx_t_13 = __pyx_t_6; __Pyx_INCREF(__pyx_t_13);
        __pyx_t_19 = 0;
        __pyx_t_17 = NULL;
      } else {
        __pyx_t_19 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5461, __pyx_L258_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5461, __pyx_L258_error)
      }
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      for (;;) {
        if (likely(!__pyx_t_17)) {
          if (likely(PyList_CheckExact(__pyx_t_13))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5461, __pyx_L258_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_13, __pyx_t_19);
            ++__pyx_t_19;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5461, __pyx_L258_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_6 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_19));
            #else
            __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_19);
            #endif
            ++__pyx_t_19;
          }
          if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5461, __pyx_L258_error)
        } else {
          __pyx_t_6 = __pyx_t_17(__pyx_t_13);
          if (unlikely(!__pyx_t_6)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5461, __pyx_L258_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_XDECREF_SET(__pyx_9genexpr50__pyx_v_mine, __pyx_t_6);
        __pyx_t_6 = 0;
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_XDECREF_SET(__pyx_9genexpr50__pyx_v_idx, __pyx_t_5);
        __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5461, __pyx_L258_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_5);
        __pyx_t_5 = __pyx_t_6;
        __pyx_t_6 = 0;
        __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_9genexpr50__pyx_v_idx, __pyx_v_mine_remove_idxs, Py_NE)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5461, __pyx_L258_error)
        if (__pyx_t_3) {
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_8, (PyObject*)__pyx_9genexpr50__pyx_v_mine))) __PYX_ERR(0, 5461, __pyx_L258_error)
        }
      }
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_9genexpr50__pyx_v_idx); __pyx_9genexpr50__pyx_v_idx = 0;
      __Pyx_XDECREF(__pyx_9genexpr50__pyx_v_mine); __pyx_9genexpr50__pyx_v_mine = 0;
      goto __pyx_L263_exit_scope;
      __pyx_L258_error:;
      __Pyx_XDECREF(__pyx_9genexpr50__pyx_v_idx); __pyx_9genexpr50__pyx_v_idx = 0;
      __Pyx_XDECREF(__pyx_9genexpr50__pyx_v_mine); __pyx_9genexpr50__pyx_v_mine = 0;
      goto __pyx_L1_error;
      __pyx_L263_exit_scope:;
    } /* exit inner scope */
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5461, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mines, __pyx_t_8) < 0) __PYX_ERR(0, 5461, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+5462:         self.game_state.asteroids.extend(new_asteroids)

  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5462, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5462, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __pyx_t_8 = __pyx_t_6;
  __Pyx_INCREF(__pyx_t_8);
  __pyx_t_7 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_new_asteroids};
    __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5462, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 5463: 

+5464:         if not wait_out_mines:

  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_wait_out_mines); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5464, __pyx_L1_error)
  __pyx_t_4 = (!__pyx_t_3);
  if (__pyx_t_4) {
/* … */
  }

 5465:             # Check ship/asteroid collisions

 5466:             # This DOES NOT account for the other ship! Since we can't predict their behavior, I'll just assume the other ship doesn't exist instead of wrongly predicting stuff that doesn't end up happening.

+5467:             if not self.ship_state.is_respawning:

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5467, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5467, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5467, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_3 = (!__pyx_t_4);
    if (__pyx_t_3) {
/* … */
      goto __pyx_L265;
    }

+5468:                 if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5468, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5468, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (__pyx_t_3) {
/* … */
      }

+5469:                     if self.respawn_maneuver_pass_number == 0:  # REMOVE_FOR_COMPETITION

        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5469, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5469, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (__pyx_t_3) {
/* … */
        }

+5470:                         assert return_value is None  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_3 = (__pyx_v_return_value == Py_None);
            if (unlikely(!__pyx_t_3)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 5470, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 5470, __pyx_L1_error)
          #endif

 5471:                 # asteroid_remove_idxs = []

+5472:                 for a_idx, asteroid in enumerate(self.game_state.asteroids):

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_6 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5472, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5472, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) {
        __pyx_t_5 = __pyx_t_8; __Pyx_INCREF(__pyx_t_5);
        __pyx_t_19 = 0;
        __pyx_t_17 = NULL;
      } else {
        __pyx_t_19 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5472, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5472, __pyx_L1_error)
      }
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      for (;;) {
        if (likely(!__pyx_t_17)) {
          if (likely(PyList_CheckExact(__pyx_t_5))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5472, __pyx_L1_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_19);
            ++__pyx_t_19;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5472, __pyx_L1_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_19));
            #else
            __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_19);
            #endif
            ++__pyx_t_19;
          }
          if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5472, __pyx_L1_error)
        } else {
          __pyx_t_8 = __pyx_t_17(__pyx_t_5);
          if (unlikely(!__pyx_t_8)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5472, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_8);
        __pyx_t_8 = 0;
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_XDECREF_SET(__pyx_v_a_idx, __pyx_t_6);
        __pyx_t_8 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5472, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_6);
        __pyx_t_6 = __pyx_t_8;
        __pyx_t_8 = 0;
/* … */
        __pyx_L268_continue:;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      goto __pyx_L276_for_end;
      __pyx_L269_break:;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      goto __pyx_L276_for_end;
      __pyx_L276_for_end:;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5473:                     if a_idx in asteroid_remove_idxs:

        __pyx_t_3 = (__Pyx_PySet_ContainsTF(__pyx_v_a_idx, __pyx_v_asteroid_remove_idxs, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5473, __pyx_L1_error)
        if (__pyx_t_3) {
/* … */
        }

+5474:                         continue

          goto __pyx_L268_continue;

 5475:                     #if check_collision(self.ship_state.position[0], self.ship_state.position[1], SHIP_RADIUS, asteroid.position[0], asteroid.position[1], asteroid.radius):

+5476:                     delta_x = self.ship_state.position[0] - asteroid.position[0]

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5476, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5476, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5476, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5476, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5476, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = PyNumber_Subtract(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5476, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_13);
        __pyx_t_13 = 0;

+5477:                     delta_y = self.ship_state.position[1] - asteroid.position[1]

        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5477, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5477, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5477, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5477, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5477, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_Subtract(__pyx_t_13, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5477, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_9);
        __pyx_t_9 = 0;

+5478:                     separation = SHIP_RADIUS + asteroid.radius

        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5478, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5478, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_13 = PyNumber_Add(__pyx_t_9, __pyx_t_8); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5478, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_13);
        __pyx_t_13 = 0;

+5479:                     if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

        __pyx_t_13 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_8 = PyObject_RichCompare(__pyx_t_13, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (__pyx_t_4) {
        } else {
          __pyx_t_3 = __pyx_t_4;
          goto __pyx_L272_bool_binop_done;
        }
        __pyx_t_8 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_13 = PyObject_RichCompare(__pyx_t_8, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (__pyx_t_4) {
        } else {
          __pyx_t_3 = __pyx_t_4;
          goto __pyx_L272_bool_binop_done;
        }
        __pyx_t_13 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_8 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_9 = PyNumber_Add(__pyx_t_13, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_13 = PyObject_RichCompare(__pyx_t_9, __pyx_t_8, Py_LE); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5479, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_3 = __pyx_t_4;
        __pyx_L272_bool_binop_done:;
        if (__pyx_t_3) {
/* … */
        }

+5480:                         if asteroid.size != 1:

          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5480, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_3 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_13, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5480, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          if (__pyx_t_3) {
/* … */
          }

+5481:                             self.game_state.asteroids.extend(forecast_asteroid_ship_splits(asteroid, 0, self.ship_state.velocity, self.game_state))

            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5481, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5481, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_29);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_8 = __pyx_t_29;
            __Pyx_INCREF(__pyx_t_8);
            __pyx_t_18 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_forecast_asteroid_ship_splits); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5481, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5481, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_30);
            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_30, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5481, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
            __pyx_t_30 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 5481, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_30);
            __pyx_t_7 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_1))) {
              __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_1);
              assert(__pyx_t_18);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
              __Pyx_INCREF(__pyx_t_18);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
              __pyx_t_7 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[5] = {__pyx_t_18, __pyx_v_asteroid, __pyx_mstate_global->__pyx_int_0, __pyx_t_2, __pyx_t_30};
              __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5481, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
            }
            __pyx_t_7 = 0;
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_9};
              __pyx_t_13 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
              if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5481, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
            }
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+5482:                         asteroid_remove_idxs.add(a_idx)

          __pyx_t_12 = PySet_Add(__pyx_v_asteroid_remove_idxs, __pyx_v_a_idx); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 5482, __pyx_L1_error)

 5483:                         # Stop checking this ship's collisions. And also return saying the ship took damage!

+5484:                         return_value = False

          __Pyx_INCREF(Py_False);
          __Pyx_DECREF_SET(__pyx_v_return_value, Py_False);

+5485:                         self.ship_crashed = True

          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_crashed, Py_True) < 0) __PYX_ERR(0, 5485, __pyx_L1_error)

+5486:                         self.ship_state.lives_remaining -= 1

          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5486, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5486, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = __Pyx_PyLong_SubtractObjC(__pyx_t_29, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5486, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5486, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_lives_remaining, __pyx_t_13) < 0) __PYX_ERR(0, 5486, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5487:                         self.ship_state.is_respawning = True

          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5487, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_is_respawning, Py_True) < 0) __PYX_ERR(0, 5487, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5488:                         self.ship_state.speed = 0.0

          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5488, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_speed, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 5488, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5489:                         self.ship_state.velocity = (0.0, 0.0)

          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5489, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          if (__Pyx_PyObject_SetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_velocity, __pyx_mstate_global->__pyx_tuple[0]) < 0) __PYX_ERR(0, 5489, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;

+5490:                         self.respawn_timer = 3.0

          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_mstate_global->__pyx_float_3_0) < 0) __PYX_ERR(0, 5490, __pyx_L1_error)

+5491:                         break

          goto __pyx_L269_break;

+5492:             elif self.respawn_maneuver_pass_number == 1:

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_respawn_maneuver_pass_number); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5492, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5492, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_3) {
/* … */
    }
    __pyx_L265:;

+5493:                 assert self.halt_shooting  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_halt_shooting); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5493, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5493, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_3)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5493, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5493, __pyx_L1_error)
      #endif

+5494:                 for a_idx, asteroid in enumerate(self.game_state.asteroids):

      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_6 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5494, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5494, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (likely(PyList_CheckExact(__pyx_t_29)) || PyTuple_CheckExact(__pyx_t_29)) {
        __pyx_t_5 = __pyx_t_29; __Pyx_INCREF(__pyx_t_5);
        __pyx_t_19 = 0;
        __pyx_t_17 = NULL;
      } else {
        __pyx_t_19 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_29); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5494, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5494, __pyx_L1_error)
      }
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      for (;;) {
        if (likely(!__pyx_t_17)) {
          if (likely(PyList_CheckExact(__pyx_t_5))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5494, __pyx_L1_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            __pyx_t_29 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_19);
            ++__pyx_t_19;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5494, __pyx_L1_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_29 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_19));
            #else
            __pyx_t_29 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_19);
            #endif
            ++__pyx_t_19;
          }
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5494, __pyx_L1_error)
        } else {
          __pyx_t_29 = __pyx_t_17(__pyx_t_5);
          if (unlikely(!__pyx_t_29)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5494, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_XDECREF_SET(__pyx_v_asteroid, __pyx_t_29);
        __pyx_t_29 = 0;
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_XDECREF_SET(__pyx_v_a_idx, __pyx_t_6);
        __pyx_t_29 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5494, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_6);
        __pyx_t_6 = __pyx_t_29;
        __pyx_t_29 = 0;
/* … */
        __pyx_L277_continue:;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      goto __pyx_L284_for_end;
      __pyx_L278_break:;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      goto __pyx_L284_for_end;
      __pyx_L284_for_end:;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5495:                     if a_idx in asteroid_remove_idxs:

        __pyx_t_3 = (__Pyx_PySet_ContainsTF(__pyx_v_a_idx, __pyx_v_asteroid_remove_idxs, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5495, __pyx_L1_error)
        if (__pyx_t_3) {
/* … */
        }

+5496:                         continue

          goto __pyx_L277_continue;

 5497:                     #if check_collision(self.ship_state.position[0], self.ship_state.position[1], SHIP_RADIUS, asteroid.position[0], asteroid.position[1], asteroid.radius):

+5498:                     delta_x = self.ship_state.position[0] - asteroid.position[0]

        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5498, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_29, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5498, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5498, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5498, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_13, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5498, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = PyNumber_Subtract(__pyx_t_29, __pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5498, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_x, __pyx_t_13);
        __pyx_t_13 = 0;

+5499:                     delta_y = self.ship_state.position[1] - asteroid.position[1]

        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_29 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = PyNumber_Subtract(__pyx_t_13, __pyx_t_29); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5499, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_XDECREF_SET(__pyx_v_delta_y, __pyx_t_9);
        __pyx_t_9 = 0;

+5500:                     separation = SHIP_RADIUS + asteroid.radius

        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_RADIUS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5500, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_asteroid, __pyx_mstate_global->__pyx_n_u_radius); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5500, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_13 = PyNumber_Add(__pyx_t_9, __pyx_t_29); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5500, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __Pyx_XDECREF_SET(__pyx_v_separation, __pyx_t_13);
        __pyx_t_13 = 0;

+5501:                     if abs(delta_x) <= separation and abs(delta_y) <= separation and delta_x*delta_x + delta_y*delta_y <= separation*separation:

        __pyx_t_13 = __Pyx_PyNumber_Absolute(__pyx_v_delta_x); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_29 = PyObject_RichCompare(__pyx_t_13, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_29); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_29); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        if (__pyx_t_4) {
        } else {
          __pyx_t_3 = __pyx_t_4;
          goto __pyx_L281_bool_binop_done;
        }
        __pyx_t_29 = __Pyx_PyNumber_Absolute(__pyx_v_delta_y); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_13 = PyObject_RichCompare(__pyx_t_29, __pyx_v_separation, Py_LE); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (__pyx_t_4) {
        } else {
          __pyx_t_3 = __pyx_t_4;
          goto __pyx_L281_bool_binop_done;
        }
        __pyx_t_13 = PyNumber_Multiply(__pyx_v_delta_x, __pyx_v_delta_x); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_29 = PyNumber_Multiply(__pyx_v_delta_y, __pyx_v_delta_y); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_9 = PyNumber_Add(__pyx_t_13, __pyx_t_29); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_29 = PyNumber_Multiply(__pyx_v_separation, __pyx_v_separation); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_29);
        __pyx_t_13 = PyObject_RichCompare(__pyx_t_9, __pyx_t_29, Py_LE); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
        __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5501, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_3 = __pyx_t_4;
        __pyx_L281_bool_binop_done:;
        if (__pyx_t_3) {
/* … */
        }

 5502:                         # The ship and asteroid are overlapping, while the ship is doing a respawn maneuver.

 5503:                         # We want to track this, so that we can begin to shoot asteroids right after we're no longer overlapping with any, before we finish the respawn maneuver and get a couple more hits in

+5504:                         self.last_timestep_colliding = self.initial_timestep + self.future_timesteps

          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5504, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5504, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_29);
          __pyx_t_9 = PyNumber_Add(__pyx_t_13, __pyx_t_29); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5504, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_colliding, __pyx_t_9) < 0) __PYX_ERR(0, 5504, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5505:                         break

          goto __pyx_L278_break;

 5506:         # Cull asteroids marked for removal

+5507:         if asteroid_remove_idxs:

  __pyx_t_3 = (__Pyx_PySet_GET_SIZE(__pyx_v_asteroid_remove_idxs) != 0);
  if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_3 < 0))) __PYX_ERR(0, 5507, __pyx_L1_error)
  if (__pyx_t_3) {
/* … */
  }

 5508:             #start_cull_time = time.perf_counter()

+5509:             self.game_state.asteroids = [asteroid for idx, asteroid in enumerate(self.game_state.asteroids) if idx not in asteroid_remove_idxs]

    { /* enter inner scope */
      __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5509, __pyx_L288_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
      __pyx_t_5 = __pyx_mstate_global->__pyx_int_0;
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5509, __pyx_L288_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_29 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5509, __pyx_L288_error)
      __Pyx_GOTREF(__pyx_t_29);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (likely(PyList_CheckExact(__pyx_t_29)) || PyTuple_CheckExact(__pyx_t_29)) {
        __pyx_t_9 = __pyx_t_29; __Pyx_INCREF(__pyx_t_9);
        __pyx_t_19 = 0;
        __pyx_t_17 = NULL;
      } else {
        __pyx_t_19 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_29); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5509, __pyx_L288_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5509, __pyx_L288_error)
      }
      __Pyx_DECREF(__pyx_t_29); __pyx_t_29 = 0;
      for (;;) {
        if (likely(!__pyx_t_17)) {
          if (likely(PyList_CheckExact(__pyx_t_9))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5509, __pyx_L288_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            __pyx_t_29 = __Pyx_PyList_GetItemRef(__pyx_t_9, __pyx_t_19);
            ++__pyx_t_19;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5509, __pyx_L288_error)
              #endif
              if (__pyx_t_19 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_29 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_19));
            #else
            __pyx_t_29 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_19);
            #endif
            ++__pyx_t_19;
          }
          if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5509, __pyx_L288_error)
        } else {
          __pyx_t_29 = __pyx_t_17(__pyx_t_9);
          if (unlikely(!__pyx_t_29)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5509, __pyx_L288_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_XDECREF_SET(__pyx_9genexpr51__pyx_v_asteroid, __pyx_t_29);
        __pyx_t_29 = 0;
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_XDECREF_SET(__pyx_9genexpr51__pyx_v_idx, __pyx_t_5);
        __pyx_t_29 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_29)) __PYX_ERR(0, 5509, __pyx_L288_error)
        __Pyx_GOTREF(__pyx_t_29);
        __Pyx_DECREF(__pyx_t_5);
        __pyx_t_5 = __pyx_t_29;
        __pyx_t_29 = 0;
        __pyx_t_3 = (__Pyx_PySet_ContainsTF(__pyx_9genexpr51__pyx_v_idx, __pyx_v_asteroid_remove_idxs, Py_NE)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5509, __pyx_L288_error)
        if (__pyx_t_3) {
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_9genexpr51__pyx_v_asteroid))) __PYX_ERR(0, 5509, __pyx_L288_error)
        }
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_9genexpr51__pyx_v_asteroid); __pyx_9genexpr51__pyx_v_asteroid = 0;
      __Pyx_XDECREF(__pyx_9genexpr51__pyx_v_idx); __pyx_9genexpr51__pyx_v_idx = 0;
      goto __pyx_L293_exit_scope;
      __pyx_L288_error:;
      __Pyx_XDECREF(__pyx_9genexpr51__pyx_v_asteroid); __pyx_9genexpr51__pyx_v_asteroid = 0;
      __Pyx_XDECREF(__pyx_9genexpr51__pyx_v_idx); __pyx_9genexpr51__pyx_v_idx = 0;
      goto __pyx_L1_error;
      __pyx_L293_exit_scope:;
    } /* exit inner scope */
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5509, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_6) < 0) __PYX_ERR(0, 5509, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 5510:             #sim_cull_total_time += time.perf_counter() - start_cull_time

 5511: 

+5512:         if not wait_out_mines:

  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_wait_out_mines); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5512, __pyx_L1_error)
  __pyx_t_4 = (!__pyx_t_3);
  if (__pyx_t_4) {
/* … */
  }

 5513:             # Checking collisions with the other ship isn't a great idea since this isn't 100% sure. This models the other ship as stationary, which probably won't be true, unless their controller is the null controller.

 5514:             '''

 5515:             # Check ship/ship collisions

 5516:             if not self.ship_state.is_respawning:

 5517:                 if ENABLE_ASSERTIONS:

 5518:                     assert return_value is None

 5519:                 if self.get_instantaneous_ship_collision():

 5520:                     print(f"COLLISION WITH OTHER SHIP!!!")

 5521:                     return_value = False

 5522:                     self.ship_crashed = True

 5523:                     self.ship_state.lives_remaining -= 1

 5524:                     self.ship_state.is_respawning = True

 5525:                     self.ship_state.speed = 0.0

 5526:                     self.ship_state.velocity = (0.0, 0.0)

 5527:                     self.respawn_timer = 3.0

 5528:             '''

+5529:             self.future_timesteps += 1

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5529, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5529, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps, __pyx_t_6) < 0) __PYX_ERR(0, 5529, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+5530:             self.game_state.sim_frame += 1

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5530, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sim_frame); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5530, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5530, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5530, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_PyObject_SetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sim_frame, __pyx_t_6) < 0) __PYX_ERR(0, 5530, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 5531:         #sim_update_total_time += time.perf_counter() - start_time

+5532:         if return_value is None:

  __pyx_t_4 = (__pyx_v_return_value == Py_None);
  if (__pyx_t_4) {
/* … */
  }

+5533:             return True

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;

 5534:         else:

+5535:             return return_value

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_return_value);
    __pyx_r = __pyx_v_return_value;
    goto __pyx_L0;
  }

 5536: 

+5537:     def rotate_heading(self, heading_difference_deg: float, shoot_on_first_timestep: bool = False) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_57rotate_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_57rotate_heading = {"rotate_heading", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_57rotate_heading, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_57rotate_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  double __pyx_v_heading_difference_deg;
  PyObject *__pyx_v_shoot_on_first_timestep = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("rotate_heading (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_heading_difference_deg,&__pyx_mstate_global->__pyx_n_u_shoot_on_first_timestep,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5537, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5537, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5537, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5537, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "rotate_heading", 0) < 0) __PYX_ERR(0, 5537, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("rotate_heading", 0, 2, 3, i); __PYX_ERR(0, 5537, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5537, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5537, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5537, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_heading_difference_deg = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_heading_difference_deg == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5537, __pyx_L3_error)
    __pyx_v_shoot_on_first_timestep = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("rotate_heading", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 5537, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.rotate_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_56rotate_heading(__pyx_self, __pyx_v_self, __pyx_v_heading_difference_deg, __pyx_v_shoot_on_first_timestep);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_56rotate_heading(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, double __pyx_v_heading_difference_deg, PyObject *__pyx_v_shoot_on_first_timestep) {
  PyObject *__pyx_v_target_heading = NULL;
  PyObject *__pyx_v_still_need_to_turn = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_INCREF(__pyx_v_shoot_on_first_timestep);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.Matrix.rotate_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_target_heading);
  __Pyx_XDECREF(__pyx_v_still_need_to_turn);
  __Pyx_XDECREF(__pyx_v_shoot_on_first_timestep);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5537, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_heading_difference_deg, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5537, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_shoot_on_first_timestep, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5537, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5537, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_57rotate_heading, 0, __pyx_mstate_global->__pyx_n_u_Matrix_rotate_heading, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[174])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5537, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[94]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_rotate_heading, __pyx_t_2) < 0) __PYX_ERR(0, 5537, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+5538:         target_heading = (self.ship_state.heading + heading_difference_deg) % 360.0

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5538, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5538, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5538, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5538, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyFloat_RemainderObjC(__pyx_t_3, __pyx_mstate_global->__pyx_float_360_0, 360.0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5538, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_target_heading = __pyx_t_1;
  __pyx_t_1 = 0;

+5539:         still_need_to_turn = heading_difference_deg

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5539, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_still_need_to_turn = __pyx_t_1;
  __pyx_t_1 = 0;

+5540:         while abs(still_need_to_turn) > SHIP_MAX_TURN_RATE*DELTA_TIME + EPS:

  while (1) {
    __pyx_t_1 = __Pyx_PyNumber_Absolute(__pyx_v_still_need_to_turn); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 5540, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (!__pyx_t_5) break;

+5541:             assert -SHIP_MAX_TURN_RATE <= SHIP_MAX_TURN_RATE*sign(heading_difference_deg) <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5541, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_3 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5541, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5541, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_4 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5541, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_7 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5541, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_8 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_4);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_8 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5541, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_6 = PyNumber_Multiply(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5541, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_t_6, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5541, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_1)) {
        __Pyx_DECREF(__pyx_t_1);
        __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5541, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_1 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5541, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 5541, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_5)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 5541, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 5541, __pyx_L1_error)
    #endif

+5542:             if not self.update(0.0, SHIP_MAX_TURN_RATE*sign(heading_difference_deg), shoot_on_first_timestep, False):

    __pyx_t_6 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_7 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_9 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_8 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_7);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_8 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_9};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5542, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[5] = {__pyx_t_6, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_4, __pyx_v_shoot_on_first_timestep, Py_False};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (5-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 5542, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_10 = (!__pyx_t_5);
    if (__pyx_t_10) {
/* … */
    }

+5543:                 return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      goto __pyx_L0;

+5544:             shoot_on_first_timestep = False

    __Pyx_INCREF(Py_False);
    __Pyx_DECREF_SET(__pyx_v_shoot_on_first_timestep, Py_False);

+5545:             still_need_to_turn -= SHIP_MAX_TURN_RATE*sign(heading_difference_deg)*DELTA_TIME

    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5545, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5545, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5545, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
      __pyx_t_8 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5545, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5545, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Multiply(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5545, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_InPlaceSubtract(__pyx_v_still_need_to_turn, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5545, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF_SET(__pyx_v_still_need_to_turn, __pyx_t_4);
    __pyx_t_4 = 0;
  }

+5546:         assert -SHIP_MAX_TURN_RATE <= still_need_to_turn*FPS <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5546, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5546, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5546, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = PyNumber_Multiply(__pyx_v_still_need_to_turn, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5546, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5546, __pyx_L1_error)
    if (__Pyx_PyObject_IsTrue(__pyx_t_4)) {
      __Pyx_DECREF(__pyx_t_4);
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5546, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5546, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 5546, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_10)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 5546, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 5546, __pyx_L1_error)
  #endif

+5547:         if not self.update(0.0, still_need_to_turn*FPS, shoot_on_first_timestep, False):

  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5547, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Multiply(__pyx_v_still_need_to_turn, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5547, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[5] = {__pyx_t_2, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_3, __pyx_v_shoot_on_first_timestep, Py_False};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (5-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5547, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 5547, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = (!__pyx_t_10);
  if (__pyx_t_5) {
/* … */
  }

+5548:             return False

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

+5549:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5549, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 5549, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_5) {
/* … */
  }

+5550:             assert abs(angle_difference_deg(target_heading, self.ship_state.heading)) <= GRAIN, f"{target_heading=}, {self.ship_state.heading=}"  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_angle_difference_deg); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5550, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5550, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5550, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_8 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_2))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
        __pyx_t_8 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_target_heading, __pyx_t_6};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5550, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_14neo_controller_GRAIN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5550, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5550, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 5550, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_5)) {
        __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_target_heading), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_2), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_target_heading;
        __pyx_t_11[1] = __pyx_t_6;
        __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_self_ship_state_heading;
        __pyx_t_11[3] = __pyx_t_4;
        __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_11, 4, 15 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 26 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4));
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0);
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        __PYX_ERR(0, 5550, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 5550, __pyx_L1_error)
    #endif

+5551:         return True

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_True);
  __pyx_r = Py_True;
  goto __pyx_L0;

 5552: 

+5553:     def get_rotate_heading_move_sequence(self, heading_difference_deg: float, shoot_on_first_timestep: bool = False) -> list[Action]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_59get_rotate_heading_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_59get_rotate_heading_move_sequence = {"get_rotate_heading_move_sequence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_59get_rotate_heading_move_sequence, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_59get_rotate_heading_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  double __pyx_v_heading_difference_deg;
  PyObject *__pyx_v_shoot_on_first_timestep = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_rotate_heading_move_sequence (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_heading_difference_deg,&__pyx_mstate_global->__pyx_n_u_shoot_on_first_timestep,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5553, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5553, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5553, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5553, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_rotate_heading_move_sequence", 0) < 0) __PYX_ERR(0, 5553, __pyx_L3_error)
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_rotate_heading_move_sequence", 0, 2, 3, i); __PYX_ERR(0, 5553, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5553, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5553, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5553, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_heading_difference_deg = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_heading_difference_deg == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5553, __pyx_L3_error)
    __pyx_v_shoot_on_first_timestep = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_rotate_heading_move_sequence", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 5553, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_rotate_heading_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_58get_rotate_heading_move_sequence(__pyx_self, __pyx_v_self, __pyx_v_heading_difference_deg, __pyx_v_shoot_on_first_timestep);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_58get_rotate_heading_move_sequence(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, double __pyx_v_heading_difference_deg, PyObject *__pyx_v_shoot_on_first_timestep) {
  PyObject *__pyx_v_move_sequence = 0;
  PyObject *__pyx_v_still_need_to_turn = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_INCREF(__pyx_v_shoot_on_first_timestep);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("neo_controller.Matrix.get_rotate_heading_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_move_sequence);
  __Pyx_XDECREF(__pyx_v_still_need_to_turn);
  __Pyx_XDECREF(__pyx_v_shoot_on_first_timestep);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5553, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_heading_difference_deg, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5553, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_shoot_on_first_timestep, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5553, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Action) < 0) __PYX_ERR(0, 5553, __pyx_L1_error)
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_59get_rotate_heading_move_sequence, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_rotate_heading_move_s, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[175])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5553, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[94]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_rotate_heading_move_sequence, __pyx_t_3) < 0) __PYX_ERR(0, 5553, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+5554:         move_sequence: list[Action] = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5554, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_move_sequence = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+5555:         if abs(heading_difference_deg) < GRAIN:

  __pyx_t_2 = fabs(__pyx_v_heading_difference_deg); 
  __pyx_t_3 = (__pyx_t_2 < __pyx_v_14neo_controller_GRAIN);
  if (__pyx_t_3) {
/* … */
  }

 5556:             # We still need a null sequence here, so that we don't end up with a 0 frame maneuver!

+5557:             move_sequence.append(Action(thrust=0.0, turn_rate=0.0, fire=shoot_on_first_timestep))

    __pyx_t_4 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
    __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_4, NULL};
      __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5557, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_7, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5557, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_7, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5557, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, __pyx_v_shoot_on_first_timestep, __pyx_t_7, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5557, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5557, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_1);
    }
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_move_sequence, ((PyObject *)__pyx_t_1)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 5557, __pyx_L1_error)
    __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;

+5558:             return move_sequence

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_move_sequence);
    __pyx_r = __pyx_v_move_sequence;
    goto __pyx_L0;

+5559:         still_need_to_turn = heading_difference_deg

  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5559, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_still_need_to_turn = __pyx_t_1;
  __pyx_t_1 = 0;

+5560:         while abs(still_need_to_turn) > SHIP_MAX_TURN_RATE*DELTA_TIME:

  while (1) {
    __pyx_t_1 = __Pyx_PyNumber_Absolute(__pyx_v_still_need_to_turn); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5560, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5560, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5560, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_4 = PyNumber_Multiply(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5560, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5560, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5560, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (!__pyx_t_3) break;

+5561:             assert -SHIP_MAX_TURN_RATE <= SHIP_MAX_TURN_RATE*sign(heading_difference_deg) <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_4 = PyNumber_Negative(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_10};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5561, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_9 = PyNumber_Multiply(__pyx_t_7, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5561, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_t_9, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5561, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_1)) {
        __Pyx_DECREF(__pyx_t_1);
        __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5561, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_1 = PyObject_RichCompare(__pyx_t_9, __pyx_t_7, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5561, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5561, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_3)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 5561, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 5561, __pyx_L1_error)
    #endif

+5562:             move_sequence.append(Action(thrust=0.0, turn_rate=SHIP_MAX_TURN_RATE*sign(heading_difference_deg), fire=shoot_on_first_timestep))

    __pyx_t_9 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
    __pyx_t_4 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5562, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5562, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_12 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5562, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_11))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_12};
      __pyx_t_10 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5562, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
    }
    __pyx_t_11 = PyNumber_Multiply(__pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5562, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_9, NULL};
      __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5562, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_10, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5562, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_t_11, __pyx_t_10, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5562, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, __pyx_v_shoot_on_first_timestep, __pyx_t_10, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5562, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5562, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_1);
    }
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_move_sequence, ((PyObject *)__pyx_t_1)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 5562, __pyx_L1_error)
    __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0;

+5563:             shoot_on_first_timestep = False

    __Pyx_INCREF(Py_False);
    __Pyx_DECREF_SET(__pyx_v_shoot_on_first_timestep, Py_False);

+5564:             still_need_to_turn -= SHIP_MAX_TURN_RATE*sign(heading_difference_deg)*DELTA_TIME

    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_10 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_9 = PyFloat_FromDouble(__pyx_v_heading_difference_deg); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_11))) {
      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_11);
      assert(__pyx_t_10);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5564, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_11 = PyNumber_Multiply(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyNumber_Multiply(__pyx_t_11, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyNumber_InPlaceSubtract(__pyx_v_still_need_to_turn, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF_SET(__pyx_v_still_need_to_turn, __pyx_t_4);
    __pyx_t_4 = 0;
  }

+5565:         if abs(still_need_to_turn) > EPS:

  __pyx_t_4 = __Pyx_PyNumber_Absolute(__pyx_v_still_need_to_turn); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_11 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5565, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5565, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__pyx_t_3) {
/* … */
  }

+5566:             assert -SHIP_MAX_TURN_RATE <= still_need_to_turn*FPS <= SHIP_MAX_TURN_RATE  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5566, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_1 = PyNumber_Negative(__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5566, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5566, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_4 = PyNumber_Multiply(__pyx_v_still_need_to_turn, __pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5566, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_11 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_LE); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5566, __pyx_L1_error)
      if (__Pyx_PyObject_IsTrue(__pyx_t_11)) {
        __Pyx_DECREF(__pyx_t_11);
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5566, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_11 = PyObject_RichCompare(__pyx_t_4, __pyx_t_9, Py_LE); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5566, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5566, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_3)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 5566, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 5566, __pyx_L1_error)
    #endif

+5567:             move_sequence.append(Action(thrust=0.0, turn_rate=still_need_to_turn*FPS, fire=shoot_on_first_timestep))

    __pyx_t_4 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action);
    __pyx_t_1 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_Action); 
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5567, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = PyNumber_Multiply(__pyx_v_still_need_to_turn, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5567, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_4, NULL};
      __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5567, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_9, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5567, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_t_10, __pyx_t_9, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5567, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire, __pyx_v_shoot_on_first_timestep, __pyx_t_9, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5567, __pyx_L1_error)
      __pyx_t_11 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_1, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5567, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_11);
    }
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_move_sequence, ((PyObject *)__pyx_t_11)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 5567, __pyx_L1_error)
    __Pyx_DECREF((PyObject *)__pyx_t_11); __pyx_t_11 = 0;

+5568:         return move_sequence

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_move_sequence);
  __pyx_r = __pyx_v_move_sequence;
  goto __pyx_L0;

 5569: 

+5570:     def accelerate(self, target_speed: float, turn_rate: float = 0.0) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_61accelerate(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_61accelerate = {"accelerate", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_61accelerate, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_61accelerate(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  double __pyx_v_target_speed;
  double __pyx_v_turn_rate;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("accelerate (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_target_speed,&__pyx_mstate_global->__pyx_n_u_turn_rate,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5570, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5570, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5570, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5570, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "accelerate", 0) < 0) __PYX_ERR(0, 5570, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("accelerate", 0, 2, 3, i); __PYX_ERR(0, 5570, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5570, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5570, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5570, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_self = values[0];
    __pyx_v_target_speed = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_target_speed == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5570, __pyx_L3_error)
    if (values[2]) {
      __pyx_v_turn_rate = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5570, __pyx_L3_error)
    } else {
      __pyx_v_turn_rate = ((double)((double)0.0));
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("accelerate", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 5570, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.accelerate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_60accelerate(__pyx_self, __pyx_v_self, __pyx_v_target_speed, __pyx_v_turn_rate);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_60accelerate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, double __pyx_v_target_speed, double __pyx_v_turn_rate) {
  PyObject *__pyx_v_drag = NULL;
  PyObject *__pyx_v_drag_amount = NULL;
  PyObject *__pyx_v_adjust_drag_by = NULL;
  PyObject *__pyx_v_delta_speed_to_target = NULL;
  PyObject *__pyx_v_thrust_amount = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.Matrix.accelerate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_drag);
  __Pyx_XDECREF(__pyx_v_drag_amount);
  __Pyx_XDECREF(__pyx_v_adjust_drag_by);
  __Pyx_XDECREF(__pyx_v_delta_speed_to_target);
  __Pyx_XDECREF(__pyx_v_thrust_amount);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5570, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5570, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5570, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_target_speed, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5570, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5570, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5570, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_61accelerate, 0, __pyx_mstate_global->__pyx_n_u_Matrix_accelerate, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[176])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5570, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_accelerate, __pyx_t_9) < 0) __PYX_ERR(0, 5570, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5571:         #print(f"Accelerating to speed {target_speed} while our speed is already {self.ship_state.speed}")

 5572:         # Keep in mind speed can be negative

 5573:         # Drag will always slow down the ship

+5574:         while abs(self.ship_state.speed - target_speed) > EPS:

  while (1) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_target_speed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyNumber_Absolute(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5574, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (!__pyx_t_4) break;

+5575:             drag = -SHIP_DRAG*sign(self.ship_state.speed)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5575, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5575, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5575, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5575, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5575, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_8 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_8 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_7};
      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5575, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5575, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF_SET(__pyx_v_drag, __pyx_t_5);
    __pyx_t_5 = 0;

+5576:             drag_amount = SHIP_DRAG*DELTA_TIME

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5576, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5576, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyNumber_Multiply(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5576, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF_SET(__pyx_v_drag_amount, __pyx_t_3);
    __pyx_t_3 = 0;

+5577:             if drag_amount > abs(self.ship_state.speed):

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5577, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5577, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyNumber_Absolute(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5577, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyObject_RichCompare(__pyx_v_drag_amount, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5577, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5577, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_4) {
/* … */
    }

 5578:                 # The drag amount is reduced if it would make the ship cross 0 speed on its own

+5579:                 adjust_drag_by = abs((drag_amount - abs(self.ship_state.speed))*FPS)

      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5579, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5579, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5579, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyNumber_Subtract(__pyx_v_drag_amount, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5579, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5579, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5579, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5579, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF_SET(__pyx_v_adjust_drag_by, __pyx_t_2);
      __pyx_t_2 = 0;

+5580:                 drag -= adjust_drag_by*sign(drag)

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5580, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_8 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_8 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_drag};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5580, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_3 = PyNumber_Multiply(__pyx_v_adjust_drag_by, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5580, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = PyNumber_InPlaceSubtract(__pyx_v_drag, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5580, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF_SET(__pyx_v_drag, __pyx_t_2);
      __pyx_t_2 = 0;

+5581:             delta_speed_to_target = target_speed - self.ship_state.speed

    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_target_speed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5581, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5581, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5581, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5581, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF_SET(__pyx_v_delta_speed_to_target, __pyx_t_3);
    __pyx_t_3 = 0;

+5582:             thrust_amount = delta_speed_to_target*FPS - drag

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5582, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyNumber_Multiply(__pyx_v_delta_speed_to_target, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5582, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyNumber_Subtract(__pyx_t_5, __pyx_v_drag); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5582, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF_SET(__pyx_v_thrust_amount, __pyx_t_3);
    __pyx_t_3 = 0;

 5583:             #print(f"{thrust_amount=}, clamped thrust: {min(max(-SHIP_MAX_THRUST, thrust_amount), SHIP_MAX_THRUST)}, {self.ship_state.speed=}, {target_speed=}, {delta_speed_to_target=}")

+5584:             thrust_amount = min(max(-SHIP_MAX_THRUST, thrust_amount), SHIP_MAX_THRUST)

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5584, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_thrust_amount);
    __pyx_t_5 = __pyx_v_thrust_amount;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5584, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = PyNumber_Negative(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5584, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_t_7, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5584, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5584, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_4) {
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_2 = __pyx_t_5;
    } else {
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_2 = __pyx_t_7;
    }
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_5 = __pyx_t_2;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5584, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5584, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_4) {
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_2 = __pyx_t_3;
    } else {
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_2 = __pyx_t_5;
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __pyx_t_2;
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF_SET(__pyx_v_thrust_amount, __pyx_t_3);
    __pyx_t_3 = 0;

 5585: 

+5586:             if not self.update(thrust_amount, turn_rate):

    __pyx_t_2 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_thrust_amount, __pyx_t_5};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5586, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 5586, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_9 = (!__pyx_t_4);
    if (__pyx_t_9) {
/* … */
    }
  }

+5587:                 return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      goto __pyx_L0;

+5588:         return True

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_True);
  __pyx_r = Py_True;
  goto __pyx_L0;

 5589: 

+5590:     def cruise(self, cruise_time: int, cruise_turn_rate: float = 0.0) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_63cruise(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_63cruise = {"cruise", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_63cruise, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_63cruise(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_cruise_time = 0;
  double __pyx_v_cruise_turn_rate;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cruise (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_cruise_time,&__pyx_mstate_global->__pyx_n_u_cruise_turn_rate,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5590, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5590, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5590, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5590, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "cruise", 0) < 0) __PYX_ERR(0, 5590, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("cruise", 0, 2, 3, i); __PYX_ERR(0, 5590, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5590, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5590, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5590, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_self = values[0];
    __pyx_v_cruise_time = ((PyObject*)values[1]);
    if (values[2]) {
      __pyx_v_cruise_turn_rate = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_cruise_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5590, __pyx_L3_error)
    } else {
      __pyx_v_cruise_turn_rate = ((double)((double)0.0));
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("cruise", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 5590, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.cruise", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cruise_time), (&PyLong_Type), 0, "cruise_time", 2))) __PYX_ERR(0, 5590, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_62cruise(__pyx_self, __pyx_v_self, __pyx_v_cruise_time, __pyx_v_cruise_turn_rate);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_62cruise(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_cruise_time, double __pyx_v_cruise_turn_rate) {
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.Matrix.cruise", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v__);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5590, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5590, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5590, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_cruise_time, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5590, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_cruise_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5590, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5590, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_63cruise, 0, __pyx_mstate_global->__pyx_n_u_Matrix_cruise, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[177])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5590, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_cruise, __pyx_t_2) < 0) __PYX_ERR(0, 5590, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 5591:         # Maintain current speed

+5592:         for _ in range(cruise_time):

  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_range);
  __pyx_t_3 = __pyx_builtin_range; 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_cruise_time};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5592, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5592, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5592, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  for (;;) {
    if (likely(!__pyx_t_6)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5592, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5592, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5592, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5592, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 5592, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v__, ((PyObject*)__pyx_t_1));
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+5593:             if not self.update(sign(self.ship_state.speed)*SHIP_DRAG, cruise_turn_rate):

    __pyx_t_2 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_8 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_4 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_9))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9);
      assert(__pyx_t_8);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
      __pyx_t_4 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_11};
      __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5593, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_SHIP_DRAG); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_11 = PyNumber_Multiply(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = PyFloat_FromDouble(__pyx_v_cruise_turn_rate); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_4 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_11, __pyx_t_9};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5593, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 5593, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_13 = (!__pyx_t_12);
    if (__pyx_t_13) {
/* … */
    }

+5594:                 return False

      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_False);
      __pyx_r = Py_False;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      goto __pyx_L0;

+5595:         return True

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_True);
  __pyx_r = Py_True;
  goto __pyx_L0;

 5596: 

+5597:     def get_move_sequence(self) -> list[Action]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_65get_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_65get_move_sequence = {"get_move_sequence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_65get_move_sequence, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_65get_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_move_sequence (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5597, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5597, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_move_sequence", 0) < 0) __PYX_ERR(0, 5597, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_move_sequence", 1, 1, 1, i); __PYX_ERR(0, 5597, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5597, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_move_sequence", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5597, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_64get_move_sequence(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_64get_move_sequence(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5597, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Action) < 0) __PYX_ERR(0, 5597, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_65get_move_sequence, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_move_sequence, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[178])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5597, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_move_sequence, __pyx_t_9) < 0) __PYX_ERR(0, 5597, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5598:         return self.ship_move_sequence

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5598, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 5598, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5599: 

+5600:     def get_intended_move_sequence(self) -> list[Action]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_67get_intended_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_67get_intended_move_sequence = {"get_intended_move_sequence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_67get_intended_move_sequence, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_67get_intended_move_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_intended_move_sequence (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5600, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5600, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_intended_move_sequence", 0) < 0) __PYX_ERR(0, 5600, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_intended_move_sequence", 1, 1, 1, i); __PYX_ERR(0, 5600, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5600, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_intended_move_sequence", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5600, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_intended_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_66get_intended_move_sequence(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_66get_intended_move_sequence(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_intended_move_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_Action) < 0) __PYX_ERR(0, 5600, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_67get_intended_move_sequence, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_intended_move_sequenc, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[179])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_intended_move_sequence, __pyx_t_2) < 0) __PYX_ERR(0, 5600, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+5601:         if self.intended_move_sequence:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_intended_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5601, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+5602:             return self.intended_move_sequence

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_intended_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5602, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 5602, __pyx_L1_error)
    __pyx_r = ((PyObject*)__pyx_t_1);
    __pyx_t_1 = 0;
    goto __pyx_L0;

 5603:         else:

+5604:             return self.ship_move_sequence

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5604, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 5604, __pyx_L1_error)
    __pyx_r = ((PyObject*)__pyx_t_1);
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

 5605: 

+5606:     def get_state_sequence(self) -> list[SimState]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_69get_state_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_69get_state_sequence = {"get_state_sequence", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_69get_state_sequence, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_69get_state_sequence(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_state_sequence (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5606, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5606, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_state_sequence", 0) < 0) __PYX_ERR(0, 5606, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_state_sequence", 1, 1, 1, i); __PYX_ERR(0, 5606, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5606, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_state_sequence", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5606, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_state_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_68get_state_sequence(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_68get_state_sequence(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_9genexpr52__pyx_v_a = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_AddTraceback("neo_controller.Matrix.get_state_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_9genexpr52__pyx_v_a);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5606, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_list_SimState) < 0) __PYX_ERR(0, 5606, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_69get_state_sequence, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_state_sequence, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[180])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5606, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_state_sequence, __pyx_t_9) < 0) __PYX_ERR(0, 5606, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5607:         if self.state_sequence and self.state_sequence[-1].timestep != self.initial_timestep + self.future_timesteps:

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_3) {
  } else {
    __pyx_t_1 = __pyx_t_3;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, -1L, long, 1, __Pyx_PyLong_From_long, 0, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5607, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+5608:             assert self.state_sequence[-1].timestep + 1 == self.initial_timestep + self.future_timesteps  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, -1L, long, 1, __Pyx_PyLong_From_long, 0, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 5608, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 5608, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 5608, __pyx_L1_error)
    #endif

 5609:             #print(f"In get state sequence, the final timestep was {self.state_sequence[-1]['timestep']} and we're appending the last state to make it {self.initial_timestep + self.future_timesteps}")

 5610:             #self.state_sequence.append(cast(SimState, {'timestep': self.initial_timestep + self.future_timesteps, 'ship_state': copy.copy(self.ship_state), 'game_state': self.get_game_state(), 'asteroids_pending_death': dict(self.asteroids_pending_death), 'forecasted_asteroid_splits': [copy.copy(a) for a in self.forecasted_asteroid_splits]}))

+5611:             self.state_sequence.append(SimState(

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5611, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = NULL;
    __Pyx_INCREF((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState);
    __pyx_t_5 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_SimState); 
/* … */
    __pyx_t_18 = __Pyx_PyObject_Append(__pyx_t_2, ((PyObject *)__pyx_t_4)); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 5611, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF((PyObject *)__pyx_t_4); __pyx_t_4 = 0;

+5612:                 timestep=self.initial_timestep + self.future_timesteps,

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_initial_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5612, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5612, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = PyNumber_Add(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5612, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+5613:                 ship_state=self.ship_state.copy(),

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5613, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_7 = __pyx_t_10;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_11 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5613, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
    }

+5614:                 game_state=self.get_game_state(),

    __pyx_t_7 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_11 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_game_state, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5614, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
    }

+5615:                 asteroids_pending_death=dict(self.asteroids_pending_death),

    __pyx_t_12 = NULL;
    __Pyx_INCREF((PyObject *)(&PyDict_Type));
    __pyx_t_13 = ((PyObject *)(&PyDict_Type)); 
    __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5615, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __pyx_t_11 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_14};
      __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5615, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    { /* enter inner scope */

+5616:                 forecasted_asteroid_splits=[a.copy() for a in self.forecasted_asteroid_splits]

      __pyx_t_13 = PyList_New(0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5616, __pyx_L8_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5616, __pyx_L8_error)
      __Pyx_GOTREF(__pyx_t_14);
      if (likely(PyList_CheckExact(__pyx_t_14)) || PyTuple_CheckExact(__pyx_t_14)) {
        __pyx_t_12 = __pyx_t_14; __Pyx_INCREF(__pyx_t_12);
        __pyx_t_15 = 0;
        __pyx_t_16 = NULL;
      } else {
        __pyx_t_15 = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_14); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5616, __pyx_L8_error)
        __Pyx_GOTREF(__pyx_t_12);
        __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_12); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 5616, __pyx_L8_error)
      }
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      for (;;) {
        if (likely(!__pyx_t_16)) {
          if (likely(PyList_CheckExact(__pyx_t_12))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_12);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5616, __pyx_L8_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            __pyx_t_14 = __Pyx_PyList_GetItemRef(__pyx_t_12, __pyx_t_15);
            ++__pyx_t_15;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_12);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5616, __pyx_L8_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_14 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_12, __pyx_t_15));
            #else
            __pyx_t_14 = __Pyx_PySequence_ITEM(__pyx_t_12, __pyx_t_15);
            #endif
            ++__pyx_t_15;
          }
          if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5616, __pyx_L8_error)
        } else {
          __pyx_t_14 = __pyx_t_16(__pyx_t_12);
          if (unlikely(!__pyx_t_14)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5616, __pyx_L8_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_14);
        __Pyx_XDECREF_SET(__pyx_9genexpr52__pyx_v_a, __pyx_t_14);
        __pyx_t_14 = 0;
        __pyx_t_17 = __pyx_9genexpr52__pyx_v_a;
        __Pyx_INCREF(__pyx_t_17);
        __pyx_t_11 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_17, NULL};
          __pyx_t_14 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
          if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5616, __pyx_L8_error)
          __Pyx_GOTREF(__pyx_t_14);
        }
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_13, (PyObject*)__pyx_t_14))) __PYX_ERR(0, 5616, __pyx_L8_error)
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      }
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_9genexpr52__pyx_v_a); __pyx_9genexpr52__pyx_v_a = 0;
      goto __pyx_L12_exit_scope;
      __pyx_L8_error:;
      __Pyx_XDECREF(__pyx_9genexpr52__pyx_v_a); __pyx_9genexpr52__pyx_v_a = 0;
      goto __pyx_L1_error;
      __pyx_L12_exit_scope:;
    } /* exit inner scope */
    __pyx_t_11 = 1;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 5 : 0)] = {__pyx_t_6, NULL};
      __pyx_t_12 = __Pyx_MakeVectorcallBuilderKwds(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5611, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_9, __pyx_t_12, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5611, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_8, __pyx_t_12, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5611, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, __pyx_t_10, __pyx_t_12, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5611, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_7, __pyx_t_12, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 5611, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_13, __pyx_t_12, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 5611, __pyx_L1_error)
      __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_12);
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5611, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_4);
    }

 5617:             ))

+5618:         return self.state_sequence

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5618, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (!(likely(PyList_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_4))) __PYX_ERR(0, 5618, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_4);
  __pyx_t_4 = 0;
  goto __pyx_L0;

 5619: 

+5620:     def get_sequence_length(self) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_71get_sequence_length(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_71get_sequence_length = {"get_sequence_length", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_71get_sequence_length, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_71get_sequence_length(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_sequence_length (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5620, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5620, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_sequence_length", 0) < 0) __PYX_ERR(0, 5620, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_sequence_length", 1, 1, 1, i); __PYX_ERR(0, 5620, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5620, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_sequence_length", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5620, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_sequence_length", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_70get_sequence_length(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_70get_sequence_length(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("neo_controller.Matrix.get_sequence_length", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5620, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5620, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_71get_sequence_length, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_sequence_length, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[181])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5620, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_sequence_length, __pyx_t_2) < 0) __PYX_ERR(0, 5620, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 5621:         # debug_print(f"Length of move seq: {len(self.ship_move_sequence)}, length of state seq: {len(self.state_sequence)}")

+5622:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5622, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5622, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+5623:             if not (len(self.ship_move_sequence) + 1 == len(self.state_sequence) or len(self.ship_move_sequence) == len(self.state_sequence)):  # REMOVE_FOR_COMPETITION

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_5 = ((__pyx_t_3 + 1) == __pyx_t_4);
    if (!__pyx_t_5) {
    } else {
      __pyx_t_2 = __pyx_t_5;
      goto __pyx_L5_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5623, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_5 = (__pyx_t_4 == __pyx_t_3);
    __pyx_t_2 = __pyx_t_5;
    __pyx_L5_bool_binop_done:;
    __pyx_t_5 = (!__pyx_t_2);
    if (__pyx_t_5) {
/* … */
    }

+5624:                 print(f"len(self.ship_move_sequence): {len(self.ship_move_sequence)}, len(self.state_sequence): {len(self.state_sequence)}")  # REMOVE_FOR_COMPETITION

      __pyx_t_6 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_7 = __pyx_builtin_print; 
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5624, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_3 = PyObject_Length(__pyx_t_8); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5624, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_3, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5624, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5624, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_3 = PyObject_Length(__pyx_t_9); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5624, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_3, 0, ' ', 'd'); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5624, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_len_self_ship_move_sequence;
      __pyx_t_10[1] = __pyx_t_8;
      __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_len_self_state_sequence;
      __pyx_t_10[3] = __pyx_t_9;
      __pyx_t_11 = __Pyx_PyUnicode_Join(__pyx_t_10, 4, 30 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 28 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9), 127);
      if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5624, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_12 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_11};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_12, (2-__pyx_t_12) | (__pyx_t_12*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5624, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5625:             assert len(self.ship_move_sequence) + 1 == len(self.state_sequence) or len(self.ship_move_sequence) == len(self.state_sequence)  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_2 = ((__pyx_t_3 + 1) == __pyx_t_4);
      if (!__pyx_t_2) {
      } else {
        __pyx_t_5 = __pyx_t_2;
        goto __pyx_L7_bool_binop_done;
      }
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_move_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5625, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_2 = (__pyx_t_4 == __pyx_t_3);
      __pyx_t_5 = __pyx_t_2;
      __pyx_L7_bool_binop_done:;
      if (unlikely(!__pyx_t_5)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 5625, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 5625, __pyx_L1_error)
    #endif

+5626:         return len(self.state_sequence)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_state_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5626, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5626, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5626, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyLong_CheckExact(__pyx_t_1)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 5626, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5627: 

+5628:     def get_future_timesteps(self) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_73get_future_timesteps(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_73get_future_timesteps = {"get_future_timesteps", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_73get_future_timesteps, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_73get_future_timesteps(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_future_timesteps (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5628, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5628, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_future_timesteps", 0) < 0) __PYX_ERR(0, 5628, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_future_timesteps", 1, 1, 1, i); __PYX_ERR(0, 5628, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5628, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_future_timesteps", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5628, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_future_timesteps", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_72get_future_timesteps(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_72get_future_timesteps(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_future_timesteps", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5628, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_73get_future_timesteps, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_future_timesteps, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[182])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_future_timesteps, __pyx_t_9) < 0) __PYX_ERR(0, 5628, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5629:         return self.future_timesteps

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_future_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5629, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 5629, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5630: 

+5631:     def get_position(self) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_75get_position(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_75get_position = {"get_position", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_75get_position, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_75get_position(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_position (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5631, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5631, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_position", 0) < 0) __PYX_ERR(0, 5631, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_position", 1, 1, 1, i); __PYX_ERR(0, 5631, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5631, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_position", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5631, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_position", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_74get_position(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_74get_position(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Matrix.get_position", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 5631, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_75get_position, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_position, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[183])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_position, __pyx_t_2) < 0) __PYX_ERR(0, 5631, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+5632:         return self.ship_state.position

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 5633: 

+5634:     def get_last_timestep_fired(self) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_77get_last_timestep_fired(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_77get_last_timestep_fired = {"get_last_timestep_fired", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_77get_last_timestep_fired, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_77get_last_timestep_fired(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_last_timestep_fired (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5634, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5634, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_last_timestep_fired", 0) < 0) __PYX_ERR(0, 5634, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_last_timestep_fired", 1, 1, 1, i); __PYX_ERR(0, 5634, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5634, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_last_timestep_fired", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5634, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_last_timestep_fired", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_76get_last_timestep_fired(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_76get_last_timestep_fired(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_last_timestep_fired", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5634, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_77get_last_timestep_fired, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_last_timestep_fired, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[184])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_last_timestep_fired, __pyx_t_9) < 0) __PYX_ERR(0, 5634, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5635:         return self.last_timestep_fired

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5635, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 5635, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5636: 

+5637:     def get_last_timestep_mined(self) -> int:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_79get_last_timestep_mined(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_79get_last_timestep_mined = {"get_last_timestep_mined", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_79get_last_timestep_mined, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_79get_last_timestep_mined(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_last_timestep_mined (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5637, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5637, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_last_timestep_mined", 0) < 0) __PYX_ERR(0, 5637, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_last_timestep_mined", 1, 1, 1, i); __PYX_ERR(0, 5637, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5637, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_last_timestep_mined", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5637, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_last_timestep_mined", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_78get_last_timestep_mined(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_78get_last_timestep_mined(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.Matrix.get_last_timestep_mined", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5637, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_79get_last_timestep_mined, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_last_timestep_mined, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[185])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_last_timestep_mined, __pyx_t_2) < 0) __PYX_ERR(0, 5637, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+5638:         return self.last_timestep_mined

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5638, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 5638, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5639: 

+5640:     def get_velocity(self) -> tuple[float, float]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_81get_velocity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_81get_velocity = {"get_velocity", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_81get_velocity, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_81get_velocity(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_velocity (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5640, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5640, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_velocity", 0) < 0) __PYX_ERR(0, 5640, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_velocity", 1, 1, 1, i); __PYX_ERR(0, 5640, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5640, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_velocity", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5640, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_velocity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_80get_velocity(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_80get_velocity(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Matrix.get_velocity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5640, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float) < 0) __PYX_ERR(0, 5640, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_81get_velocity, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_velocity, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[186])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5640, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_velocity, __pyx_t_9) < 0) __PYX_ERR(0, 5640, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5641:         return self.ship_state.velocity

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5641, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_velocity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5641, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 5642: 

+5643:     def get_heading(self) -> float:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_6Matrix_83get_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_6Matrix_83get_heading = {"get_heading", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_6Matrix_83get_heading, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_6Matrix_83get_heading(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_heading (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5643, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5643, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_heading", 0) < 0) __PYX_ERR(0, 5643, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_heading", 1, 1, 1, i); __PYX_ERR(0, 5643, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5643, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_heading", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5643, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.Matrix.get_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_6Matrix_82get_heading(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_6Matrix_82get_heading(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.Matrix.get_heading", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5643, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5643, __pyx_L1_error)
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_6Matrix_83get_heading, 0, __pyx_mstate_global->__pyx_n_u_Matrix_get_heading, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[187])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5643, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_heading, __pyx_t_2) < 0) __PYX_ERR(0, 5643, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+5644:         return float(self.ship_state.heading)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_heading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyNumber_Float(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5645: 

 5646: 

+5647: class KesslerController:

  __pyx_t_4 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_n_u_KesslerController, __pyx_mstate_global->__pyx_n_u_KesslerController, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_kp_u_A_ship_controller_class_for_Kes); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
/* … */
  __pyx_t_9 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_mstate_global->__pyx_n_u_KesslerController, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_KesslerController, __pyx_t_9) < 0) __PYX_ERR(0, 5647, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 5648:     """

 5649:      A ship controller class for Kessler. This can be inherited to create custom controllers that can be passed to the

 5650:     game to operate within scenarios. A valid controller contains an actions method that takes in a ship object and ass

 5651:     game_state dictionary. This action method then sets the thrust, turn_rate, and fire commands on the ship object.

 5652:     """

 5653: 

+5654:     def actions(self, ship_state: dict[str, Any], game_state: dict[str, Any]) -> tuple[float, float, bool, bool]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_17KesslerController_1actions(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_14neo_controller_17KesslerController_actions, "\n        Method processed each time step by this controller.\n        ");
static PyMethodDef __pyx_mdef_14neo_controller_17KesslerController_1actions = {"actions", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_17KesslerController_1actions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_14neo_controller_17KesslerController_actions};
static PyObject *__pyx_pw_14neo_controller_17KesslerController_1actions(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  CYTHON_UNUSED PyObject *__pyx_v_ship_state = 0;
  CYTHON_UNUSED PyObject *__pyx_v_game_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("actions (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_ship_state,&__pyx_mstate_global->__pyx_n_u_game_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5654, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5654, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5654, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5654, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "actions", 0) < 0) __PYX_ERR(0, 5654, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("actions", 1, 3, 3, i); __PYX_ERR(0, 5654, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5654, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5654, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5654, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_ship_state = ((PyObject*)values[1]);
    __pyx_v_game_state = ((PyObject*)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("actions", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 5654, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.KesslerController.actions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), (&PyDict_Type), 0, "ship_state", 2))) __PYX_ERR(0, 5654, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), (&PyDict_Type), 0, "game_state", 2))) __PYX_ERR(0, 5654, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_17KesslerController_actions(__pyx_self, __pyx_v_self, __pyx_v_ship_state, __pyx_v_game_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_17KesslerController_actions(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_ship_state, CYTHON_UNUSED PyObject *__pyx_v_game_state) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("neo_controller.KesslerController.actions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5654, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_kp_u_dict_str_Any) < 0) __PYX_ERR(0, 5654, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_kp_u_dict_str_Any) < 0) __PYX_ERR(0, 5654, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float_bool_bool) < 0) __PYX_ERR(0, 5654, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_17KesslerController_1actions, 0, __pyx_mstate_global->__pyx_n_u_KesslerController_actions, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[188])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5654, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_actions, __pyx_t_9) < 0) __PYX_ERR(0, 5654, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5655:         """

 5656:         Method processed each time step by this controller.

 5657:         """

 5658: 

+5659:         raise NotImplementedError('Your derived KesslerController must include an actions method for control input.')

  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_NotImplementedError);
  __pyx_t_3 = __pyx_builtin_NotImplementedError; 
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Your_derived_KesslerController_m};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5659, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __PYX_ERR(0, 5659, __pyx_L1_error)

 5660: 

 5661: 

 5662:     # Property to store the ID for the ship this controller is attached to during a scenario

+5663:     @property

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_17KesslerController_3ship_id(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_17KesslerController_3ship_id = {"ship_id", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_17KesslerController_3ship_id, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_17KesslerController_3ship_id(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ship_id (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5663, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5663, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ship_id", 0) < 0) __PYX_ERR(0, 5663, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ship_id", 1, 1, 1, i); __PYX_ERR(0, 5663, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5663, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ship_id", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5663, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.KesslerController.ship_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_17KesslerController_2ship_id(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_17KesslerController_2ship_id(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.KesslerController.ship_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_property);
  __pyx_t_3 = __pyx_builtin_property; 
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5663, __pyx_L1_error)
  __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_17KesslerController_3ship_id, 0, __pyx_mstate_global->__pyx_n_u_KesslerController_ship_id, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[189])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_10, __pyx_t_5);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_10};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5663, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_id_2, __pyx_t_9) < 0) __PYX_ERR(0, 5663, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5664:     def ship_id(self) -> int:

+5665:         return self._ship_id if self._ship_id else 0

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5665, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_3) {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5665, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (!(likely(PyLong_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_2))) __PYX_ERR(0, 5665, __pyx_L1_error)
    __pyx_t_1 = __pyx_t_2;
    __pyx_t_2 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_t_1 = __pyx_mstate_global->__pyx_int_0;
  }
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5666: 

+5667:     @ship_id.setter

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_17KesslerController_5ship_id(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_17KesslerController_5ship_id = {"ship_id", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_17KesslerController_5ship_id, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_17KesslerController_5ship_id(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_value = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ship_id (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_value,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5667, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5667, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5667, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ship_id", 0) < 0) __PYX_ERR(0, 5667, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ship_id", 1, 2, 2, i); __PYX_ERR(0, 5667, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5667, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5667, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_value = ((PyObject*)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ship_id", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5667, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.KesslerController.ship_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyLong_Type), 0, "value", 2))) __PYX_ERR(0, 5668, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_17KesslerController_4ship_id(__pyx_self, __pyx_v_self, __pyx_v_value);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_17KesslerController_4ship_id(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.KesslerController.ship_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = NULL;
  __pyx_t_10 = PyObject_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_id_2);
  if (unlikely(!__pyx_t_10)) {
    PyErr_Clear();
    __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_ship_id_2);
  }
  if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_setter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_value, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5667, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5667, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_17KesslerController_5ship_id, 0, __pyx_mstate_global->__pyx_n_u_KesslerController_ship_id, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[190])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_10);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5667, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_id_2, __pyx_t_9) < 0) __PYX_ERR(0, 5667, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5668:     def ship_id(self, value: int) -> None:

+5669:         self._ship_id = value

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id, __pyx_v_value) < 0) __PYX_ERR(0, 5669, __pyx_L1_error)

 5670: 

+5671:     @property

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_17KesslerController_7name(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_17KesslerController_7name = {"name", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_17KesslerController_7name, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_17KesslerController_7name(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("name (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5671, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5671, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "name", 0) < 0) __PYX_ERR(0, 5671, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("name", 1, 1, 1, i); __PYX_ERR(0, 5671, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5671, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5671, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.KesslerController.name", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_17KesslerController_6name(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_17KesslerController_6name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("neo_controller.KesslerController.name", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_property);
  __pyx_t_5 = __pyx_builtin_property; 
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 5671, __pyx_L1_error)
  __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_17KesslerController_7name, 0, __pyx_mstate_global->__pyx_n_u_KesslerController_name, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[191])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5671, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_10, __pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_10};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5671, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_t_9) < 0) __PYX_ERR(0, 5671, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5672:     def name(self) -> str:

+5673:         raise NotImplementedError(f"This controller {self.__class__} needs to have a name() property specified.")

  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_NotImplementedError);
  __pyx_t_3 = __pyx_builtin_NotImplementedError; 
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_4, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_This_controller;
  __pyx_t_6[1] = __pyx_t_5;
  __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u_needs_to_have_a_name_property_s;
  __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, 16 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 43, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5));
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_7 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5673, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __PYX_ERR(0, 5673, __pyx_L1_error)

 5674: 

 5675: 

+5676: class NeoController(KesslerController):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_KesslerController); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_9 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_10 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_NeoController, __pyx_mstate_global->__pyx_n_u_NeoController, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, (PyObject *) NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (__pyx_t_4 != __pyx_t_9) {
    if (unlikely((PyDict_SetItemString(__pyx_t_10, "__orig_bases__", __pyx_t_9) < 0))) __PYX_ERR(0, 5676, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
  __pyx_t_11 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_NeoController, __pyx_t_4, __pyx_t_10, NULL, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NeoController, __pyx_t_11) < 0) __PYX_ERR(0, 5676, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+5677:     @property

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_1name(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_1name = {"name", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_1name, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_1name(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("name (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5677, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5677, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "name", 0) < 0) __PYX_ERR(0, 5677, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("name", 1, 1, 1, i); __PYX_ERR(0, 5677, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5677, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5677, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.name", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_name(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_name(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = NULL;
  __Pyx_INCREF(__pyx_builtin_property);
  __pyx_t_3 = __pyx_builtin_property; 
  __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5677, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 5677, __pyx_L1_error)
  __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_1name, 0, __pyx_mstate_global->__pyx_n_u_NeoController_name, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[192])); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5677, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_11, __pyx_t_8);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_11};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5677, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_t_9) < 0) __PYX_ERR(0, 5677, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5678:     def name(self) -> str:

+5679:         return "Neo"

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_Neo);
  __pyx_r = __pyx_mstate_global->__pyx_n_u_Neo;
  goto __pyx_L0;

 5680: 

+5681:     @property

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_3custom_sprite_path(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_3custom_sprite_path = {"custom_sprite_path", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_3custom_sprite_path, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_3custom_sprite_path(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("custom_sprite_path (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5681, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5681, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "custom_sprite_path", 0) < 0) __PYX_ERR(0, 5681, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("custom_sprite_path", 1, 1, 1, i); __PYX_ERR(0, 5681, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5681, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("custom_sprite_path", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5681, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.custom_sprite_path", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_2custom_sprite_path(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_2custom_sprite_path(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = NULL;
  __Pyx_INCREF(__pyx_builtin_property);
  __pyx_t_11 = __pyx_builtin_property; 
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5681, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_str_2) < 0) __PYX_ERR(0, 5681, __pyx_L1_error)
  __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_3custom_sprite_path, 0, __pyx_mstate_global->__pyx_n_u_NeoController_custom_sprite_path, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[193])); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5681, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_8, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_8};
    __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5681, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
  }
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_custom_sprite_path, __pyx_t_9) < 0) __PYX_ERR(0, 5681, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5682:     def custom_sprite_path(self) -> str:

+5683:         return "Neo.png"

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Neo_png);
  __pyx_r = __pyx_mstate_global->__pyx_kp_u_Neo_png;
  goto __pyx_L0;

 5684: 

+5685:     def get_total_sim_ts(self) -> int:  # REMOVE_FOR_COMPETITION

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_5get_total_sim_ts(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_5get_total_sim_ts = {"get_total_sim_ts", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_5get_total_sim_ts, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_5get_total_sim_ts(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  CYTHON_UNUSED PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_total_sim_ts (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5685, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5685, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_total_sim_ts", 0) < 0) __PYX_ERR(0, 5685, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_total_sim_ts", 1, 1, 1, i); __PYX_ERR(0, 5685, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5685, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_total_sim_ts", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5685, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.get_total_sim_ts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_4get_total_sim_ts(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_4get_total_sim_ts(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("neo_controller.NeoController.get_total_sim_ts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5685, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5685, __pyx_L1_error)
  __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_5get_total_sim_ts, 0, __pyx_mstate_global->__pyx_n_u_NeoController_get_total_sim_ts, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[194])); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5685, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_11, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_get_total_sim_ts, __pyx_t_11) < 0) __PYX_ERR(0, 5685, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

+5686:         return total_sim_timesteps  # REMOVE_FOR_COMPETITION

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_total_sim_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5686, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyLong_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_1))) __PYX_ERR(0, 5686, __pyx_L1_error)
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 5687: 

+5688:     def __init__(self, chromosome: Optional[tuple[float, float, float, float, float, float, float, float, float]] = None) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_7__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_7__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_7__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_7__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_chromosome = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_chromosome,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5688, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5688, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5688, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 5688, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 2, i); __PYX_ERR(0, 5688, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5688, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5688, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_chromosome = ((PyObject*)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 5688, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_chromosome), (&PyTuple_Type), 1, "chromosome", 2))) __PYX_ERR(0, 5688, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_6__init__(__pyx_self, __pyx_v_self, __pyx_v_chromosome);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_6__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_chromosome) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("neo_controller.NeoController.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_11 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5688, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_chromosome, __pyx_mstate_global->__pyx_kp_u_Optional_tuple_float_float_float_2) < 0) __PYX_ERR(0, 5688, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5688, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_7__init__, 0, __pyx_mstate_global->__pyx_n_u_NeoController___init, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[195])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5688, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_mstate_global->__pyx_tuple[89]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_11);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_9) < 0) __PYX_ERR(0, 5688, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5689:         #print(BUILD_NUMBER)

 5690:         #print(__file__)

+5691:         self.reset(chromosome)

  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_chromosome};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_reset, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5691, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 5692:         #self.ship_id: int = -1 # Dangerous!

 5693:         #self._ship_id: int = -1

 5694: 

+5695:     def reset(self, chromosome: Optional[tuple[float, float, float, float, float, float, float, float, float]] = None) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_9reset(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_9reset = {"reset", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_9reset, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_9reset(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_chromosome = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_chromosome,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5695, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5695, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5695, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "reset", 0) < 0) __PYX_ERR(0, 5695, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("reset", 0, 1, 2, i); __PYX_ERR(0, 5695, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5695, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5695, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject*)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_chromosome = ((PyObject*)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("reset", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 5695, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_chromosome), (&PyTuple_Type), 1, "chromosome", 2))) __PYX_ERR(0, 5695, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_8reset(__pyx_self, __pyx_v_self, __pyx_v_chromosome);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_8reset(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_chromosome) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("neo_controller.NeoController.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_chromosome, __pyx_mstate_global->__pyx_kp_u_Optional_tuple_float_float_float_2) < 0) __PYX_ERR(0, 5695, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5695, __pyx_L1_error)
  __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_9reset, 0, __pyx_mstate_global->__pyx_n_u_NeoController_reset, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[196])); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_11, __pyx_mstate_global->__pyx_tuple[89]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_11, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_reset, __pyx_t_11) < 0) __PYX_ERR(0, 5695, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

+5696:         self.init_done = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_init_done, Py_False) < 0) __PYX_ERR(0, 5696, __pyx_L1_error)

 5697:         #self.ship_id = None

 5698:         # DO NOT OVERWRITE self.ship_id. That will cause the controller to break, since Kessler manages that itself. If we want to track our ship id, use a different variable name.

+5699:         self.ship_id_internal: int = -1

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id_internal, __pyx_mstate_global->__pyx_int_neg_1) < 0) __PYX_ERR(0, 5699, __pyx_L1_error)

+5700:         self.current_timestep: int = -1

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_mstate_global->__pyx_int_neg_1) < 0) __PYX_ERR(0, 5700, __pyx_L1_error)

+5701:         self.action_queue: deque[tuple[int, float, float, bool, bool]] = deque()

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5701, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5701, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue, __pyx_t_1) < 0) __PYX_ERR(0, 5701, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5702:         self.game_state_plotter: Optional[GameStatePlotter] = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter, Py_None) < 0) __PYX_ERR(0, 5702, __pyx_L1_error)

+5703:         self.actioned_timesteps: set[int] = set()

  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5703, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actioned_timesteps, __pyx_t_1) < 0) __PYX_ERR(0, 5703, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5704:         self.sims_this_planning_period: list[CompletedSimulation] = []  # The first sim in the list is stationary targetting, and the rest is maneuvers

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5704, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period, __pyx_t_1) < 0) __PYX_ERR(0, 5704, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5705:         self.best_fitness_this_planning_period: float = -INFINITY

  __pyx_t_1 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5705, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_t_1) < 0) __PYX_ERR(0, 5705, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5706:         self.best_fitness_this_planning_period_index: int = INT_NEG_INF

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5706, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_1) < 0) __PYX_ERR(0, 5706, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5707:         self.second_best_fitness_this_planning_period: float = -INFINITY

  __pyx_t_1 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5707, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_1) < 0) __PYX_ERR(0, 5707, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5708:         self.second_best_fitness_this_planning_period_index: int = INT_NEG_INF

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5708, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_1) < 0) __PYX_ERR(0, 5708, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5709:         self.stationary_targetting_sim_index: int = INT_NEG_INF

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5709, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index, __pyx_t_1) < 0) __PYX_ERR(0, 5709, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5710:         self.game_state_to_base_planning: Optional[BasePlanningGameState] = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning, Py_None) < 0) __PYX_ERR(0, 5710, __pyx_L1_error)

+5711:         self.base_gamestate_analysis: Optional[tuple[float, float, float, float, int, float, int, int]] = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestate_analysis, Py_None) < 0) __PYX_ERR(0, 5711, __pyx_L1_error)

+5712:         self.set_of_base_gamestate_timesteps: set[int] = set()

  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5712, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_of_base_gamestate_timesteps, __pyx_t_1) < 0) __PYX_ERR(0, 5712, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5713:         self.base_gamestates: dict[int, Any] = {}  # Key is timestep, value is the state

  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5713, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestates, __pyx_t_1) < 0) __PYX_ERR(0, 5713, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5714:         self.other_ships_exist: bool = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist, Py_False) < 0) __PYX_ERR(0, 5714, __pyx_L1_error)

 5715:         #self.reality_move_sequence: list[dict[str, Any]] = []

+5716:         self.simulated_gamestate_history: dict[int, SimState] = {}

  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5716, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history, __pyx_t_1) < 0) __PYX_ERR(0, 5716, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5717:         self.lives_remaining_that_we_did_respawn_maneuver_for: set[int] = set()

  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5717, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp, __pyx_t_1) < 0) __PYX_ERR(0, 5717, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5718:         self.last_timestep_ship_is_respawning = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_ship_is_respawning, Py_False) < 0) __PYX_ERR(0, 5718, __pyx_L1_error)

+5719:         if chromosome is not None:

  __pyx_t_5 = (__pyx_v_chromosome != ((PyObject*)Py_None));
  if (__pyx_t_5) {
/* … */
  }

 5720:             global fitness_function_weights

+5721:             fitness_function_weights = chromosome

    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_fitness_function_weights, __pyx_v_chromosome) < 0) __PYX_ERR(0, 5721, __pyx_L1_error)

 5722:         # For performance controller

+5723:         self.outside_controller_time_intervals: list[float] = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5723, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outside_controller_time_interval, __pyx_t_1) < 0) __PYX_ERR(0, 5723, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5724:         self.inside_controller_iteration_time_intervals: list[float] = []  # Stores recent iteration times for rolling average of PERFORMANCE_CONTROLLER_ROLLING_AVERAGE_FRAME_INTERVAL frames

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5724, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_inside_controller_iteration_time, __pyx_t_1) < 0) __PYX_ERR(0, 5724, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5725:         self.last_entrance_time: float = NAN

  __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5725, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_entrance_time, __pyx_t_1) < 0) __PYX_ERR(0, 5725, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5726:         self.last_exit_time: float = NAN

  __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5726, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_exit_time, __pyx_t_1) < 0) __PYX_ERR(0, 5726, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5727:         self.last_iteration_start_time: float = NAN

  __pyx_t_1 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5727, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time, __pyx_t_1) < 0) __PYX_ERR(0, 5727, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5728:         self.average_iteration_time = DELTA_TIME*0.1

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5728, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_mstate_global->__pyx_float_0_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5728, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_average_iteration_time, __pyx_t_3) < 0) __PYX_ERR(0, 5728, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 5729: 

 5730:         # Clear globals

 5731:         global explanation_messages_with_timestamps

+5732:         explanation_messages_with_timestamps.clear()

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_explanation_messages_with_timest); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_clear); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5732, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 5733:         #global total_abs_cruise_speed

 5734:         #total_abs_cruise_speed = SHIP_MAX_SPEED/2

 5735:         #global total_cruise_timesteps

 5736:         #total_cruise_timesteps = round(MAX_CRUISE_TIMESTEPS/2)

 5737:         #global total_maneuvers_to_learn_from

 5738:         #total_maneuvers_to_learn_from = 1

 5739:         global abs_cruise_speeds, cruise_timesteps, unwrap_cache, total_sim_timesteps, overall_fitness_record

+5740:         abs_cruise_speeds = [SHIP_MAX_SPEED/2]

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 5740, __pyx_L1_error);
  __pyx_t_6 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_abs_cruise_speeds, __pyx_t_3) < 0) __PYX_ERR(0, 5740, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+5741:         cruise_timesteps = [round(MAX_CRUISE_TIMESTEPS/2)]

  __pyx_t_6 = NULL;
  __Pyx_INCREF(__pyx_builtin_round);
  __pyx_t_1 = __pyx_builtin_round; 
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MAX_CRUISE_TIMESTEPS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_PyLong_TrueDivideObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_7};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5741, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 5741, __pyx_L1_error);
  __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_cruise_timesteps, __pyx_t_1) < 0) __PYX_ERR(0, 5741, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5742:         overall_fitness_record.clear()

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5742, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_clear); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5742, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5742, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5743:         unwrap_cache.clear()

  __pyx_t_6 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_unwrap_cache); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_clear); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
    assert(__pyx_t_6);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5744:         total_sim_timesteps = 0  # REMOVE_FOR_COMPETITION

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_total_sim_timesteps, __pyx_mstate_global->__pyx_int_0) < 0) __PYX_ERR(0, 5744, __pyx_L1_error)

 5745: 

 5746: 

+5747:     def finish_init(self, game_state: GameState, ship_state: Ship) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_11finish_init(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_11finish_init = {"finish_init", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_11finish_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_11finish_init(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("finish_init (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_ship_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5747, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5747, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5747, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5747, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "finish_init", 0) < 0) __PYX_ERR(0, 5747, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("finish_init", 1, 3, 3, i); __PYX_ERR(0, 5747, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5747, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5747, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5747, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[1]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("finish_init", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 5747, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.finish_init", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 5747, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 5747, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_10finish_init(__pyx_self, __pyx_v_self, __pyx_v_game_state, __pyx_v_ship_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_10finish_init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.NeoController.finish_init", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_11 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5747, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 5747, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 5747, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5747, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_11finish_init, 0, __pyx_mstate_global->__pyx_n_u_NeoController_finish_init, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[197])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5747, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_11);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_finish_init, __pyx_t_9) < 0) __PYX_ERR(0, 5747, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5748:         # If we need the game state or ship state to finish init, we can use this function to do that

+5749:         if self.ship_id_internal == -1:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id_internal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5749, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+5750:             self.ship_id_internal = ship_state.id

    __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_ship_state->id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id_internal, __pyx_t_1) < 0) __PYX_ERR(0, 5750, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5751:         if GAMESTATE_PLOTTING:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_GAMESTATE_PLOTTING); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5751, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5751, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+5752:             self.game_state_plotter = GameStatePlotter(game_state)  # REMOVE_FOR_COMPETITION

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_GameStatePlotter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5752, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_game_state)};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5752, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_t_1) < 0) __PYX_ERR(0, 5752, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5753:         if len(get_other_ships(game_state, self.ship_id_internal)) > 0:

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_other_ships); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5753, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id_internal); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5753, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_4, ((PyObject *)__pyx_v_game_state), __pyx_t_6};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5753, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_7 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5753, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_2 = (__pyx_t_7 > 0);
  if (__pyx_t_2) {
/* … */
    goto __pyx_L5;
  }

+5754:             self.other_ships_exist = True

    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist, Py_True) < 0) __PYX_ERR(0, 5754, __pyx_L1_error)

+5755:             print_explanation("I've got another ship friend here with me. I'll try coexisting with them, but be careful to avoid them.", self.current_timestep)

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5755, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5755, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_I_ve_got_another_ship_friend_her, __pyx_t_4};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5755, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 5756:         else:

+5757:             self.other_ships_exist = False

  /*else*/ {
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist, Py_False) < 0) __PYX_ERR(0, 5757, __pyx_L1_error)

+5758:             print_explanation("I'm alone. I can see into the future perfectly!", self.current_timestep)

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5758, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5758, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_I_m_alone_I_can_see_into_the_fut, __pyx_t_3};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5758, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }
  __pyx_L5:;

 5759:         # asteroid_density = control.Antecedent(arange(0, 11, 1), 'asteroid_density')

 5760:         # asteroids_entropy = control.Antecedent(arange(0, 11, 1), 'asteroids_entropy')

 5761:         # other_ship_lives = control.Antecedent(arange(0, 4, 1), 'other_ship_lives')

 5762: 

 5763:         # aggression = control.Consequent(arange(0, 1, 1), 'asteroid_growth_factor')

 5764: 

+5765:     def enqueue_action(self, timestep: int, thrust: float = 0.0, turn_rate: float = 0.0, fire: bool = False, drop_mine: bool = False) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_13enqueue_action(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_13enqueue_action = {"enqueue_action", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_13enqueue_action, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_13enqueue_action(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_timestep = 0;
  double __pyx_v_thrust;
  double __pyx_v_turn_rate;
  PyObject *__pyx_v_fire = 0;
  PyObject *__pyx_v_drop_mine = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("enqueue_action (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_timestep,&__pyx_mstate_global->__pyx_n_u_thrust,&__pyx_mstate_global->__pyx_n_u_turn_rate,&__pyx_mstate_global->__pyx_n_u_fire,&__pyx_mstate_global->__pyx_n_u_drop_mine,0};
  PyObject* values[6] = {0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5765, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "enqueue_action", 0) < 0) __PYX_ERR(0, 5765, __pyx_L3_error)
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("enqueue_action", 0, 2, 6, i); __PYX_ERR(0, 5765, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5765, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5765, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5765, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[5]) values[5] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_timestep = ((PyObject*)values[1]);
    if (values[2]) {
      __pyx_v_thrust = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_thrust == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5765, __pyx_L3_error)
    } else {
      __pyx_v_thrust = ((double)((double)0.0));
    }
    if (values[3]) {
      __pyx_v_turn_rate = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_turn_rate == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5765, __pyx_L3_error)
    } else {
      __pyx_v_turn_rate = ((double)((double)0.0));
    }
    __pyx_v_fire = values[4];
    __pyx_v_drop_mine = values[5];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("enqueue_action", 0, 2, 6, __pyx_nargs); __PYX_ERR(0, 5765, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.enqueue_action", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_timestep), (&PyLong_Type), 0, "timestep", 2))) __PYX_ERR(0, 5765, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_12enqueue_action(__pyx_self, __pyx_v_self, __pyx_v_timestep, __pyx_v_thrust, __pyx_v_turn_rate, __pyx_v_fire, __pyx_v_drop_mine);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_12enqueue_action(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_timestep, double __pyx_v_thrust, double __pyx_v_turn_rate, PyObject *__pyx_v_fire, PyObject *__pyx_v_drop_mine) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.NeoController.enqueue_action", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_11 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_8 = PyTuple_Pack(4, __pyx_t_9, __pyx_t_11, ((PyObject*)Py_False), ((PyObject*)Py_False)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __pyx_t_11 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_mstate_global->__pyx_n_u_int) < 0) __PYX_ERR(0, 5765, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_thrust, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5765, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_turn_rate, __pyx_mstate_global->__pyx_n_u_float) < 0) __PYX_ERR(0, 5765, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_fire, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5765, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_drop_mine, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5765, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5765, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_13enqueue_action, 0, __pyx_mstate_global->__pyx_n_u_NeoController_enqueue_action, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[198])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5765, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_t_8);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_11);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_enqueue_action, __pyx_t_9) < 0) __PYX_ERR(0, 5765, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+5766:         self.action_queue.append((timestep, thrust, turn_rate, fire, drop_mine))

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_thrust); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_turn_rate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_v_timestep);
  __Pyx_GIVEREF(__pyx_v_timestep);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_timestep) != (0)) __PYX_ERR(0, 5766, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 5766, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 5766, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_fire);
  __Pyx_GIVEREF(__pyx_v_fire);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_fire) != (0)) __PYX_ERR(0, 5766, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_drop_mine);
  __Pyx_GIVEREF(__pyx_v_drop_mine);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_v_drop_mine) != (0)) __PYX_ERR(0, 5766, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 5766, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 5767: 

+5768:     def performance_controller_enter(self) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_15performance_controller_enter(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_15performance_controller_enter = {"performance_controller_enter", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_15performance_controller_enter, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_15performance_controller_enter(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("performance_controller_enter (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5768, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5768, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "performance_controller_enter", 0) < 0) __PYX_ERR(0, 5768, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("performance_controller_enter", 1, 1, 1, i); __PYX_ERR(0, 5768, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5768, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("performance_controller_enter", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5768, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_enter", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_14performance_controller_enter(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_14performance_controller_enter(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_current_entrance_time = NULL;
  PyObject *__pyx_v_outside_time = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_enter", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_current_entrance_time);
  __Pyx_XDECREF(__pyx_v_outside_time);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5768, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5768, __pyx_L1_error)
  __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_15performance_controller_enter, 0, __pyx_mstate_global->__pyx_n_u_NeoController_performance_contro, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[199])); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5768, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_11, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_performance_controller_enter, __pyx_t_11) < 0) __PYX_ERR(0, 5768, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

 5769:         # Called when actions() is called

+5770:         current_entrance_time = time.perf_counter()

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5770, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_perf_counter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5770, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5770, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_current_entrance_time = __pyx_t_1;
  __pyx_t_1 = 0;

+5771:         if not isnan(self.last_exit_time):

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_exit_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_6 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5771, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_7 = (!isnan(__pyx_t_6));
  if (__pyx_t_7) {
/* … */
  }

 5772:             # Calculate time spent outside since last exit and update the rolling list

+5773:             outside_time = current_entrance_time - self.last_exit_time

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_exit_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5773, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyNumber_Subtract(__pyx_v_current_entrance_time, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5773, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_outside_time = __pyx_t_4;
    __pyx_t_4 = 0;

+5774:             self.outside_controller_time_intervals.append(outside_time)

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outside_controller_time_interval); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5774, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_v_outside_time); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 5774, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 5775:             # Keep only the last 5 elements for rolling average

+5776:             self.outside_controller_time_intervals = self.outside_controller_time_intervals[-PERFORMANCE_CONTROLLER_ROLLING_AVERAGE_FRAME_INTERVAL:]

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outside_controller_time_interval); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5776, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PERFORMANCE_CONTROLLER_ROLLING_A); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5776, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5776, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_4, 0, 0, &__pyx_t_2, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5776, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outside_controller_time_interval, __pyx_t_1) < 0) __PYX_ERR(0, 5776, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5777:         self.last_entrance_time = current_entrance_time

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_entrance_time, __pyx_v_current_entrance_time) < 0) __PYX_ERR(0, 5777, __pyx_L1_error)

 5778: 

+5779:     def performance_controller_exit(self) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_17performance_controller_exit(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_17performance_controller_exit = {"performance_controller_exit", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_17performance_controller_exit, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_17performance_controller_exit(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("performance_controller_exit (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5779, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5779, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "performance_controller_exit", 0) < 0) __PYX_ERR(0, 5779, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("performance_controller_exit", 1, 1, 1, i); __PYX_ERR(0, 5779, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5779, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("performance_controller_exit", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5779, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_exit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_16performance_controller_exit(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_16performance_controller_exit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_exit_time = NULL;
  PyObject *__pyx_v_last_iteration_end_time = NULL;
  PyObject *__pyx_v_last_iteration_time_interval = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_exit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_exit_time);
  __Pyx_XDECREF(__pyx_v_last_iteration_end_time);
  __Pyx_XDECREF(__pyx_v_last_iteration_time_interval);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_11 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5779, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_17performance_controller_exit, 0, __pyx_mstate_global->__pyx_n_u_NeoController_performance_contro_2, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[200])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5779, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_11);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_performance_controller_exit, __pyx_t_9) < 0) __PYX_ERR(0, 5779, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5780:         # Called at the end of actions()

+5781:         exit_time = time.perf_counter()

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5781, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_perf_counter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5781, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5781, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_exit_time = __pyx_t_1;
  __pyx_t_1 = 0;

+5782:         assert not isnan(self.last_entrance_time)  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_entrance_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5782, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_6 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5782, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_7 = (!isnan(__pyx_t_6));
    if (unlikely(!__pyx_t_7)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 5782, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 5782, __pyx_L1_error)
  #endif

+5783:         self.last_exit_time = exit_time

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_exit_time, __pyx_v_exit_time) < 0) __PYX_ERR(0, 5783, __pyx_L1_error)

 5784:         # Close out the final iteration, assumed to have been started before this and ended just now

+5785:         last_iteration_end_time = time.perf_counter()

  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5785, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_perf_counter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5785, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_4);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5785, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_last_iteration_end_time = __pyx_t_1;
  __pyx_t_1 = 0;

 5786:         # print(f"In perf controller exit: {last_iteration_end_time=}, {self.last_iteration_start_time=}")

+5787:         last_iteration_time_interval = last_iteration_end_time - self.last_iteration_start_time

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5787, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Subtract(__pyx_v_last_iteration_end_time, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5787, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_last_iteration_time_interval = __pyx_t_3;
  __pyx_t_3 = 0;

+5788:         assert last_iteration_time_interval >= 0.0  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_3 = PyObject_RichCompare(__pyx_v_last_iteration_time_interval, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5788, __pyx_L1_error)
    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 5788, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_7)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 5788, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 5788, __pyx_L1_error)
  #endif

+5789:         self.inside_controller_iteration_time_intervals.append(last_iteration_time_interval)

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_inside_controller_iteration_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5789, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_3, __pyx_v_last_iteration_time_interval); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 5789, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 5790:         # print(f"In perf controller exit. {self.inside_controller_iteration_time_intervals=}, {self.outside_controller_time_intervals=}")

+5791:         self.last_iteration_start_time = NAN

  __pyx_t_3 = PyFloat_FromDouble(NAN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5791, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time, __pyx_t_3) < 0) __PYX_ERR(0, 5791, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 5792: 

+5793:     def performance_controller_start_iteration(self) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_19performance_controller_start_iteration(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_19performance_controller_start_iteration = {"performance_controller_start_iteration", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_19performance_controller_start_iteration, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_19performance_controller_start_iteration(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("performance_controller_start_iteration (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5793, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5793, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "performance_controller_start_iteration", 0) < 0) __PYX_ERR(0, 5793, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("performance_controller_start_iteration", 1, 1, 1, i); __PYX_ERR(0, 5793, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5793, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("performance_controller_start_iteration", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5793, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_start_iteration", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_18performance_controller_start_iteration(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_18performance_controller_start_iteration(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_current_iteration_start_time = NULL;
  PyObject *__pyx_v_last_iteration_time_interval = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_start_iteration", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_current_iteration_start_time);
  __Pyx_XDECREF(__pyx_v_last_iteration_time_interval);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5793, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 5793, __pyx_L1_error)
  __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_19performance_controller_start_iteration, 0, __pyx_mstate_global->__pyx_n_u_NeoController_performance_contro_3, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[201])); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5793, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_11, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_performance_controller_start_ite, __pyx_t_11) < 0) __PYX_ERR(0, 5793, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

 5794:         # Call this around all iterations. Call it before each iteration, and after the last iteration. If iterations are the fences, this function is the fenceposts around each section of fence.

+5795:         if not isnan(self.last_iteration_start_time):

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5795, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5795, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = (!isnan(__pyx_t_2));
  if (__pyx_t_3) {
/* … */
    goto __pyx_L3;
  }

 5796:             # This is at least the second iteration run this timestep. Track how long the last iteration took.

+5797:             current_iteration_start_time = time.perf_counter()

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5797, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_perf_counter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5797, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5797, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_current_iteration_start_time = __pyx_t_1;
    __pyx_t_1 = 0;

+5798:             last_iteration_time_interval = current_iteration_start_time - self.last_iteration_start_time

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = PyNumber_Subtract(__pyx_v_current_iteration_start_time, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_last_iteration_time_interval = __pyx_t_6;
    __pyx_t_6 = 0;

+5799:             self.last_iteration_start_time = current_iteration_start_time

    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time, __pyx_v_current_iteration_start_time) < 0) __PYX_ERR(0, 5799, __pyx_L1_error)

+5800:             self.inside_controller_iteration_time_intervals.append(last_iteration_time_interval)

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_inside_controller_iteration_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5800, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_v_last_iteration_time_interval); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 5800, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 5801:             # Keep only the last 5 elements for rolling average

+5802:             self.inside_controller_iteration_time_intervals = self.inside_controller_iteration_time_intervals[-PERFORMANCE_CONTROLLER_ROLLING_AVERAGE_FRAME_INTERVAL:]

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_inside_controller_iteration_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5802, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PERFORMANCE_CONTROLLER_ROLLING_A); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5802, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5802, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_6, 0, 0, &__pyx_t_4, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5802, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_inside_controller_iteration_time, __pyx_t_1) < 0) __PYX_ERR(0, 5802, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 5803:             # Update average iteration time based on the rolling list

+5804:             self.average_iteration_time = sum(self.inside_controller_iteration_time_intervals)/len(self.inside_controller_iteration_time_intervals)

    __pyx_t_4 = NULL;
    __Pyx_INCREF(__pyx_builtin_sum);
    __pyx_t_6 = __pyx_builtin_sum; 
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_inside_controller_iteration_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5804, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_inside_controller_iteration_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_9 = PyObject_Length(__pyx_t_6); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5804, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyLong_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5804, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_average_iteration_time, __pyx_t_5) < 0) __PYX_ERR(0, 5804, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 5805:         else:

 5806:             # This is before the first iteration run within this controller timestep.

+5807:             self.last_iteration_start_time = time.perf_counter()

  /*else*/ {
    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5807, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_perf_counter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5807, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5807, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time, __pyx_t_5) < 0) __PYX_ERR(0, 5807, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  }
  __pyx_L3:;

 5808: 

+5809:     def performance_controller_check_whether_i_can_do_another_iteration(self) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_21performance_controller_check_whether_i_can_do_another_iteration(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_21performance_controller_check_whether_i_can_do_another_iteration = {"performance_controller_check_whether_i_can_do_another_iteration", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_21performance_controller_check_whether_i_can_do_another_iteration, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_21performance_controller_check_whether_i_can_do_another_iteration(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("performance_controller_check_whether_i_can_do_another_iteration (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5809, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5809, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "performance_controller_check_whether_i_can_do_another_iteration", 0) < 0) __PYX_ERR(0, 5809, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("performance_controller_check_whether_i_can_do_another_iteration", 1, 1, 1, i); __PYX_ERR(0, 5809, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5809, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("performance_controller_check_whether_i_can_do_another_iteration", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5809, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_check_whether_i_can_do_another_iteration", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_20performance_controller_check_whether_i_can_do_another_iteration(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_20performance_controller_check_whether_i_can_do_another_iteration(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_current_time = NULL;
  PyObject *__pyx_v_elapsed_time_inside = NULL;
  PyObject *__pyx_v_average_outside_time = NULL;
  PyObject *__pyx_v_remaining_time_budget = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("neo_controller.NeoController.performance_controller_check_whether_i_can_do_another_iteration", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_current_time);
  __Pyx_XDECREF(__pyx_v_elapsed_time_inside);
  __Pyx_XDECREF(__pyx_v_average_outside_time);
  __Pyx_XDECREF(__pyx_v_remaining_time_budget);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_11 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5809, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5809, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_21performance_controller_check_whether_i_can_do_another_iteration, 0, __pyx_mstate_global->__pyx_n_u_NeoController_performance_contro_4, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[202])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5809, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_11);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_performance_controller_check_whe, __pyx_t_9) < 0) __PYX_ERR(0, 5809, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 5810:         # Called throughout my code to check whether I can squeeze in another search iteration

+5811:         if not isnan(self.last_iteration_start_time):

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_iteration_start_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5811, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 5811, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = (!isnan(__pyx_t_2));
  if (__pyx_t_3) {
/* … */
  }

 5812:             # This is at least the second iteration run this timestep

+5813:             current_time = time.perf_counter()

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5813, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_perf_counter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5813, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5813, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_current_time = __pyx_t_1;
    __pyx_t_1 = 0;

+5814:             elapsed_time_inside = current_time - self.last_entrance_time

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_entrance_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = PyNumber_Subtract(__pyx_v_current_time, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5814, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_elapsed_time_inside = __pyx_t_6;
    __pyx_t_6 = 0;

+5815:             assert elapsed_time_inside >= 0.0  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_6 = PyObject_RichCompare(__pyx_v_elapsed_time_inside, __pyx_mstate_global->__pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5815, __pyx_L1_error)
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5815, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_3)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 5815, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 5815, __pyx_L1_error)
    #endif

+5816:             average_outside_time = sum(self.outside_controller_time_intervals)/len(self.outside_controller_time_intervals) if len(self.outside_controller_time_intervals) > 0 else 0.0

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outside_controller_time_interval); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5816, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_8 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5816, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_3 = (__pyx_t_8 > 0);
    if (__pyx_t_3) {
      __pyx_t_4 = NULL;
      __Pyx_INCREF(__pyx_builtin_sum);
      __pyx_t_5 = __pyx_builtin_sum; 
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outside_controller_time_interval); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5816, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_9};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5816, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outside_controller_time_interval); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5816, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5816, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = PyLong_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5816, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_9 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5816, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_6 = __pyx_t_9;
      __pyx_t_9 = 0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
      __pyx_t_6 = __pyx_mstate_global->__pyx_float_0_0;
    }
    __pyx_v_average_outside_time = __pyx_t_6;
    __pyx_t_6 = 0;

+5817:             remaining_time_budget = max(DELTA_TIME*MINIMUM_DELTA_TIME_FRACTION_BUDGET - elapsed_time_inside, DELTA_TIME - average_outside_time - elapsed_time_inside)

    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_9 = PyNumber_Subtract(__pyx_t_6, __pyx_v_average_outside_time); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyNumber_Subtract(__pyx_t_9, __pyx_v_elapsed_time_inside); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MINIMUM_DELTA_TIME_FRACTION_BUDG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_1 = PyNumber_Multiply(__pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyNumber_Subtract(__pyx_t_1, __pyx_v_elapsed_time_inside); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_9 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5817, __pyx_L1_error)
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5817, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (__pyx_t_3) {
      __Pyx_INCREF(__pyx_t_6);
      __pyx_t_1 = __pyx_t_6;
    } else {
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_1 = __pyx_t_5;
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __pyx_t_1;
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_remaining_time_budget = __pyx_t_6;
    __pyx_t_6 = 0;

 5818: 

 5819:             # Check if another iteration can fit within the remaining time budget

+5820:             if ENABLE_PERFORMANCE_CONTROLLER:

    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ENABLE_PERFORMANCE_CONTROLLER); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5820, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5820, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_3) {
/* … */
    }

+5821:                 if remaining_time_budget >= self.average_iteration_time*PERFORMANCE_CONTROLLER_PUSHING_THE_ENVELOPE_FUDGE_MULTIPLIER:

      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_average_iteration_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PERFORMANCE_CONTROLLER_PUSHING_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_5 = PyNumber_Multiply(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = PyObject_RichCompare(__pyx_v_remaining_time_budget, __pyx_t_5, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__pyx_t_3) {
/* … */
      }

+5822:                     return True

        __Pyx_XDECREF(__pyx_r);
        __Pyx_INCREF(Py_True);
        __pyx_r = Py_True;
        goto __pyx_L0;

 5823:                 else:

+5824:                     return False

      /*else*/ {
        __Pyx_XDECREF(__pyx_r);
        __Pyx_INCREF(Py_False);
        __pyx_r = Py_False;
        goto __pyx_L0;
      }

 5825:             else:

 5826:                 # In deterministic mode, just never do additional iterations. This will also test that the minimum iterations are sufficient for a baseline level of strategic performance.

 5827:                 # return False

+5828:                 if random.random() < 0.0:

    /*else*/ {
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5828, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5828, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5828, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_9 = PyObject_RichCompare(__pyx_t_1, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 5828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (__pyx_t_3) {
/* … */
      }

+5829:                     return True

        __Pyx_XDECREF(__pyx_r);
        __Pyx_INCREF(Py_True);
        __pyx_r = Py_True;
        goto __pyx_L0;

 5830:                 else:

+5831:                     return False

      /*else*/ {
        __Pyx_XDECREF(__pyx_r);
        __Pyx_INCREF(Py_False);
        __pyx_r = Py_False;
        goto __pyx_L0;
      }
    }

 5832:         else:

 5833:             # This is the first iteration run within this controller timestep. Let the iteration occur

+5834:             return True

  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;
  }

 5835: 

+5836:     def decide_next_action(self, game_state: GameState, ship_state: Ship) -> bool:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_23decide_next_action(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_23decide_next_action = {"decide_next_action", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_23decide_next_action, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_23decide_next_action(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state = 0;
  struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("decide_next_action (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_game_state,&__pyx_mstate_global->__pyx_n_u_ship_state,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5836, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5836, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5836, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5836, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "decide_next_action", 0) < 0) __PYX_ERR(0, 5836, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("decide_next_action", 1, 3, 3, i); __PYX_ERR(0, 5836, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5836, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5836, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5836, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_game_state = ((struct __pyx_obj_14neo_controller_GameState *)values[1]);
    __pyx_v_ship_state = ((struct __pyx_obj_14neo_controller_Ship *)values[2]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("decide_next_action", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 5836, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.decide_next_action", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_game_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_GameState, 0, "game_state", 0))) __PYX_ERR(0, 5836, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state), __pyx_mstate_global->__pyx_ptype_14neo_controller_Ship, 0, "ship_state", 0))) __PYX_ERR(0, 5836, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_22decide_next_action(__pyx_self, __pyx_v_self, __pyx_v_game_state, __pyx_v_ship_state);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_22decide_next_action(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, struct __pyx_obj_14neo_controller_GameState *__pyx_v_game_state, struct __pyx_obj_14neo_controller_Ship *__pyx_v_ship_state) {
  PyObject *__pyx_v_all_ship_pos = NULL;
  PyObject *__pyx_v_all_ship_x = NULL;
  PyObject *__pyx_v_all_ship_y = NULL;
  PyObject *__pyx_v_thing = NULL;
  PyObject *__pyx_v_state_seq = NULL;
  PyObject *__pyx_v_ship_line_x = NULL;
  PyObject *__pyx_v_ship_line_y = NULL;
  PyObject *__pyx_v_state = NULL;
  PyObject *__pyx_v_ship_pos = NULL;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_v_best_action_sim = 0;
  PyObject *__pyx_v_best_action_sim_predicted = NULL;
  PyObject *__pyx_v_best_action_fitness_predicted = NULL;
  PyObject *__pyx_v_best_action_maneuver_tuple = NULL;
  PyObject *__pyx_v_best_predicted_sim_fire_next_timestep_flag = NULL;
  PyObject *__pyx_v_best_action_sim_predicted_move_sequence = NULL;
  PyObject *__pyx_v_best_action_sim_actual_move_sequence = NULL;
  PyObject *__pyx_v_best_action_fitness = NULL;
  PyObject *__pyx_v_best_action_fitness_breakdown = NULL;
  PyObject *__pyx_v_second_best_action_sim_predicted = NULL;
  PyObject *__pyx_v_second_best_action_fitness_predicted = NULL;
  PyObject *__pyx_v_second_best_predicted_sim_fire_next_timestep_flag = NULL;
  PyObject *__pyx_v_second_best_action_sim = NULL;
  PyObject *__pyx_v_second_best_action_sim_predicted_move_sequence = NULL;
  PyObject *__pyx_v_second_best_action_sim_actual_move_sequence = NULL;
  PyObject *__pyx_v_second_best_action_fitness = NULL;
  PyObject *__pyx_v_second_best_action_fitness_breakdown = NULL;
  PyObject *__pyx_v_second_best_action_maneuver_tuple = NULL;
  PyObject *__pyx_v_best_action_sim_respawn_first_pass = NULL;
  double __pyx_v_best_action_sim_respawn_first_pass_fitness;
  PyObject *__pyx_v_best_respawn_first_pass_sim_fire_next_timestep_flag = NULL;
  PyObject *__pyx_v_best_action_sim_respawn_first_pass_move_sequence = NULL;
  PyObject *__pyx_v_stationary_safety_messages = 0;
  PyObject *__pyx_v_message = NULL;
  PyObject *__pyx_v_stationary_fitness_breakdown = NULL;
  PyObject *__pyx_v_best_move_sequence = NULL;
  PyObject *__pyx_v_best_action_sim_state_sequence = NULL;
  PyObject *__pyx_v_explanation_messages = NULL;
  PyObject *__pyx_v_explanation = NULL;
  PyObject *__pyx_v_best_action_sim_last_state = NULL;
  PyObject *__pyx_v_asteroids_pending_death = NULL;
  PyObject *__pyx_v_timestep = NULL;
  PyObject *__pyx_v_forecasted_asteroid_splits = NULL;
  PyObject *__pyx_v_next_base_game_state = NULL;
  PyObject *__pyx_v_new_ship_state = NULL;
  PyObject *__pyx_v_new_fire_next_timestep_flag = NULL;
  PyObject *__pyx_v_state_dump_dict = NULL;
  PyObject *__pyx_v_sim_state = NULL;
  PyObject *__pyx_v_flattened_asteroids_pending_death = NULL;
  PyObject *__pyx_v_move = NULL;
  PyObject *__pyx_9genexpr53__pyx_v_x = NULL;
  PyObject *__pyx_9genexpr54__pyx_v_ast_list = NULL;
  PyObject *__pyx_9genexpr54__pyx_v_ast = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_24);
  __Pyx_XDECREF(__pyx_t_25);
  __Pyx_AddTraceback("neo_controller.NeoController.decide_next_action", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_all_ship_pos);
  __Pyx_XDECREF(__pyx_v_all_ship_x);
  __Pyx_XDECREF(__pyx_v_all_ship_y);
  __Pyx_XDECREF(__pyx_v_thing);
  __Pyx_XDECREF(__pyx_v_state_seq);
  __Pyx_XDECREF(__pyx_v_ship_line_x);
  __Pyx_XDECREF(__pyx_v_ship_line_y);
  __Pyx_XDECREF(__pyx_v_state);
  __Pyx_XDECREF(__pyx_v_ship_pos);
  __Pyx_XDECREF(__pyx_v_best_action_sim);
  __Pyx_XDECREF(__pyx_v_best_action_sim_predicted);
  __Pyx_XDECREF(__pyx_v_best_action_fitness_predicted);
  __Pyx_XDECREF(__pyx_v_best_action_maneuver_tuple);
  __Pyx_XDECREF(__pyx_v_best_predicted_sim_fire_next_timestep_flag);
  __Pyx_XDECREF(__pyx_v_best_action_sim_predicted_move_sequence);
  __Pyx_XDECREF(__pyx_v_best_action_sim_actual_move_sequence);
  __Pyx_XDECREF(__pyx_v_best_action_fitness);
  __Pyx_XDECREF(__pyx_v_best_action_fitness_breakdown);
  __Pyx_XDECREF(__pyx_v_second_best_action_sim_predicted);
  __Pyx_XDECREF(__pyx_v_second_best_action_fitness_predicted);
  __Pyx_XDECREF(__pyx_v_second_best_predicted_sim_fire_next_timestep_flag);
  __Pyx_XDECREF(__pyx_v_second_best_action_sim);
  __Pyx_XDECREF(__pyx_v_second_best_action_sim_predicted_move_sequence);
  __Pyx_XDECREF(__pyx_v_second_best_action_sim_actual_move_sequence);
  __Pyx_XDECREF(__pyx_v_second_best_action_fitness);
  __Pyx_XDECREF(__pyx_v_second_best_action_fitness_breakdown);
  __Pyx_XDECREF(__pyx_v_second_best_action_maneuver_tuple);
  __Pyx_XDECREF(__pyx_v_best_action_sim_respawn_first_pass);
  __Pyx_XDECREF(__pyx_v_best_respawn_first_pass_sim_fire_next_timestep_flag);
  __Pyx_XDECREF(__pyx_v_best_action_sim_respawn_first_pass_move_sequence);
  __Pyx_XDECREF(__pyx_v_stationary_safety_messages);
  __Pyx_XDECREF(__pyx_v_message);
  __Pyx_XDECREF(__pyx_v_stationary_fitness_breakdown);
  __Pyx_XDECREF(__pyx_v_best_move_sequence);
  __Pyx_XDECREF(__pyx_v_best_action_sim_state_sequence);
  __Pyx_XDECREF(__pyx_v_explanation_messages);
  __Pyx_XDECREF(__pyx_v_explanation);
  __Pyx_XDECREF(__pyx_v_best_action_sim_last_state);
  __Pyx_XDECREF(__pyx_v_asteroids_pending_death);
  __Pyx_XDECREF(__pyx_v_timestep);
  __Pyx_XDECREF(__pyx_v_forecasted_asteroid_splits);
  __Pyx_XDECREF(__pyx_v_next_base_game_state);
  __Pyx_XDECREF(__pyx_v_new_ship_state);
  __Pyx_XDECREF(__pyx_v_new_fire_next_timestep_flag);
  __Pyx_XDECREF(__pyx_v_state_dump_dict);
  __Pyx_XDECREF(__pyx_v_sim_state);
  __Pyx_XDECREF(__pyx_v_flattened_asteroids_pending_death);
  __Pyx_XDECREF(__pyx_v_move);
  __Pyx_XDECREF(__pyx_9genexpr53__pyx_v_x);
  __Pyx_XDECREF(__pyx_9genexpr54__pyx_v_ast_list);
  __Pyx_XDECREF(__pyx_9genexpr54__pyx_v_ast);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5836, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_mstate_global->__pyx_n_u_GameState) < 0) __PYX_ERR(0, 5836, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_mstate_global->__pyx_n_u_Ship) < 0) __PYX_ERR(0, 5836, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 5836, __pyx_L1_error)
  __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_23decide_next_action, 0, __pyx_mstate_global->__pyx_n_u_NeoController_decide_next_action, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[203])); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5836, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_11, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_decide_next_action, __pyx_t_11) < 0) __PYX_ERR(0, 5836, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

+5837:         assert self.game_state_to_base_planning is not None

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5837, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = (__pyx_t_1 != Py_None);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 5837, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 5837, __pyx_L1_error)
  #endif

+5838:         assert self.best_fitness_this_planning_period_index != INT_NEG_INF  # REMOVE_FOR_COMPETITION

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5838, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5838, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5838, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5838, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 5838, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 5838, __pyx_L1_error)
  #endif

+5839:         debug_print(f"\nDeciding next action! We're picking out of {len(self.sims_this_planning_period)} total sims")

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5839, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_6, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Deciding_next_action_We_re_pick;
  __pyx_t_7[1] = __pyx_t_5;
  __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_total_sims;
  __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 44 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 11, 127);
  if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_8};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5839, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+5840:         debug_print(sorted([round(x['fitness'], 2) for x in self.sims_this_planning_period]))

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5840, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  { /* enter inner scope */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5840, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5840, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) {
      __pyx_t_10 = __pyx_t_5; __Pyx_INCREF(__pyx_t_10);
      __pyx_t_6 = 0;
      __pyx_t_11 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5840, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5840, __pyx_L5_error)
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    for (;;) {
      if (likely(!__pyx_t_11)) {
        if (likely(PyList_CheckExact(__pyx_t_10))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5840, __pyx_L5_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5840, __pyx_L5_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_6));
          #else
          __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5840, __pyx_L5_error)
      } else {
        __pyx_t_5 = __pyx_t_11(__pyx_t_10);
        if (unlikely(!__pyx_t_5)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5840, __pyx_L5_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_XDECREF_SET(__pyx_9genexpr53__pyx_v_x, __pyx_t_5);
      __pyx_t_5 = 0;
      __pyx_t_12 = NULL;
      __Pyx_INCREF(__pyx_builtin_round);
      __pyx_t_13 = __pyx_builtin_round; 
      __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_9genexpr53__pyx_v_x, __pyx_mstate_global->__pyx_n_u_fitness); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5840, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_9 = 1;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_12, __pyx_t_14, __pyx_mstate_global->__pyx_int_2};
        __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5840, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 5840, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    }
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_9genexpr53__pyx_v_x); __pyx_9genexpr53__pyx_v_x = 0;
    goto __pyx_L9_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_9genexpr53__pyx_v_x); __pyx_9genexpr53__pyx_v_x = 0;
    goto __pyx_L1_error;
    __pyx_L9_exit_scope:;
  } /* exit inner scope */
  if (unlikely((PyList_Sort(__pyx_t_3) < 0))) __PYX_ERR(0, 5840, __pyx_L1_error)
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5840, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+5841:         if PLOT_MANEUVER_TRACES:

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_PLOT_MANEUVER_TRACES); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5841, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5841, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_2) {
/* … */
  }

+5842:             all_ship_pos = []

    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5842, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_v_all_ship_pos = ((PyObject*)__pyx_t_4);
    __pyx_t_4 = 0;

+5843:             all_ship_x = []

    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5843, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_v_all_ship_x = ((PyObject*)__pyx_t_4);
    __pyx_t_4 = 0;

+5844:             all_ship_y = []

    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5844, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_v_all_ship_y = ((PyObject*)__pyx_t_4);
    __pyx_t_4 = 0;

+5845:             for thing in self.sims_this_planning_period:

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5845, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
      __pyx_t_8 = __pyx_t_4; __Pyx_INCREF(__pyx_t_8);
      __pyx_t_6 = 0;
      __pyx_t_11 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5845, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5845, __pyx_L1_error)
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    for (;;) {
      if (likely(!__pyx_t_11)) {
        if (likely(PyList_CheckExact(__pyx_t_8))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5845, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_8, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5845, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_6));
          #else
          __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5845, __pyx_L1_error)
      } else {
        __pyx_t_4 = __pyx_t_11(__pyx_t_8);
        if (unlikely(!__pyx_t_4)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5845, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_thing, __pyx_t_4);
      __pyx_t_4 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+5846:                 state_seq = thing['sim'].get_state_sequence()

      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_thing, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5846, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = __pyx_t_1;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_state_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5846, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_state_seq, __pyx_t_4);
      __pyx_t_4 = 0;

+5847:                 ship_line_x = []

      __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5847, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_ship_line_x, ((PyObject*)__pyx_t_4));
      __pyx_t_4 = 0;

+5848:                 ship_line_y = []

      __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5848, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_ship_line_y, ((PyObject*)__pyx_t_4));
      __pyx_t_4 = 0;

+5849:                 for state in state_seq:

      if (likely(PyList_CheckExact(__pyx_v_state_seq)) || PyTuple_CheckExact(__pyx_v_state_seq)) {
        __pyx_t_4 = __pyx_v_state_seq; __Pyx_INCREF(__pyx_t_4);
        __pyx_t_15 = 0;
        __pyx_t_16 = NULL;
      } else {
        __pyx_t_15 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_state_seq); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5849, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 5849, __pyx_L1_error)
      }
      for (;;) {
        if (likely(!__pyx_t_16)) {
          if (likely(PyList_CheckExact(__pyx_t_4))) {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5849, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_15);
            ++__pyx_t_15;
          } else {
            {
              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
              #if !CYTHON_ASSUME_SAFE_SIZE
              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 5849, __pyx_L1_error)
              #endif
              if (__pyx_t_15 >= __pyx_temp) break;
            }
            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
            __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_15));
            #else
            __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_15);
            #endif
            ++__pyx_t_15;
          }
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5849, __pyx_L1_error)
        } else {
          __pyx_t_1 = __pyx_t_16(__pyx_t_4);
          if (unlikely(!__pyx_t_1)) {
            PyObject* exc_type = PyErr_Occurred();
            if (exc_type) {
              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 5849, __pyx_L1_error)
              PyErr_Clear();
            }
            break;
          }
        }
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_XDECREF_SET(__pyx_v_state, __pyx_t_1);
        __pyx_t_1 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+5850:                     ship_pos = state.ship_state.position

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_state, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5850, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5850, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_pos, __pyx_t_3);
        __pyx_t_3 = 0;

+5851:                     all_ship_pos.append(ship_pos)

        __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_all_ship_pos, __pyx_v_ship_pos); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 5851, __pyx_L1_error)

+5852:                     ship_line_x.append(ship_pos[0])

        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_ship_pos, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5852, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_ship_line_x, __pyx_t_3); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 5852, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+5853:                     ship_line_y.append(ship_pos[1])

        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_ship_pos, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5853, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_ship_line_y, __pyx_t_3); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 5853, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+5854:                 all_ship_x.append(ship_line_x)

      __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_all_ship_x, __pyx_v_ship_line_x); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 5854, __pyx_L1_error)

+5855:                 all_ship_y.append(ship_line_y)

      __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_all_ship_y, __pyx_v_ship_line_y); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 5855, __pyx_L1_error)

+5856:             if len(all_ship_x) > PLOT_MANEUVER_MIN_TRACE_FOR_PLOT:

    __pyx_t_6 = __Pyx_PyList_GET_SIZE(__pyx_v_all_ship_x); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5856, __pyx_L1_error)
    __pyx_t_8 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5856, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_PLOT_MANEUVER_MIN_TRACE_FOR_PLOT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5856, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_8, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5856, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5856, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_2) {
/* … */
    }

+5857:                 for i in range(len(all_ship_x)):

      __pyx_t_6 = __Pyx_PyList_GET_SIZE(__pyx_v_all_ship_x); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5857, __pyx_L1_error)
      __pyx_t_15 = __pyx_t_6;
      for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_15; __pyx_t_18+=1) {
        __pyx_v_i = __pyx_t_18;

+5858:                     plt.scatter(all_ship_x[i], all_ship_y[i], linewidths=1.0, label=f"Maneuver {i}")

        __pyx_t_4 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5858, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_scatter); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5858, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_all_ship_x, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5858, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_all_ship_y, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5858, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5858, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_13 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Maneuver, __pyx_t_5); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5858, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_9 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_1))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
          assert(__pyx_t_4);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
          __pyx_t_9 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_4, __pyx_t_8, __pyx_t_10};
          __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5858, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_linewidths, __pyx_mstate_global->__pyx_float_1_0, __pyx_t_5, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 5858, __pyx_L1_error)
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_label, __pyx_t_13, __pyx_t_5, __pyx_callargs+3, 1) < 0) __PYX_ERR(0, 5858, __pyx_L1_error)
          __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_1, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5);
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5858, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      }

+5859:                 plt.xlim(0, 1000)

      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5859, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_xlim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5859, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[27], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5859, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[27] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_1000); if (unlikely(!__pyx_mstate_global->__pyx_tuple[27])) __PYX_ERR(0, 5859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[27]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[27]);

+5860:                 plt.ylim(0, 800)

      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5860, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ylim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5860, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[28], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5860, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[28] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_800); if (unlikely(!__pyx_mstate_global->__pyx_tuple[28])) __PYX_ERR(0, 5860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[28]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[28]);

+5861:                 plt.show()

      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_plt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5861, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_show); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5861, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_13))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_13);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5861, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 5862: 

 5863:         #time.sleep(10)

 5864:         #if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

 5865:         #    assert self.stationary_targetting_sim_index != INT_NEG_INF or self.game_state_to_base_planning['ship_state'].bullets_remaining == 0 or self.game_state_to_base_planning['respawning'] or not is_close_to_zero(self.game_state_to_base_planning['ship_state'].speed)  # REMOVE_FOR_COMPETITION

 5866:         # print(f"Deciding next action, Respawn maneuver status is: {self.game_state_to_base_planning['respawning']}")

 5867:         # Go through the list of planned maneuvers and pick the one with the best fitness function score

 5868:         # Update the state to base planning off of, so Neo can get to work on planning the next set of moves while this current set of moves executes

 5869:         # print('Going through sorted sims list to pick the best action')

 5870:         best_action_sim: Matrix

+5871:         if self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['state_type'] == 'predicted':

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_state_type); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_predicted, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5871, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L20;
  }

 5872:             # Since the game is non-deterministic, we need to apply our simulated moves onto the actual corrected state, so errors don't build up

+5873:             best_action_sim_predicted: Matrix = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['sim']

    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5873, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5873, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5873, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5873, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_best_action_sim_predicted = __pyx_t_1;
    __pyx_t_1 = 0;

 5874:             #print('pred sim id', best_action_sim_predicted.get_sim_id())

 5875:             # debug_print(f"\nPredicted best action sim first state:", best_action_sim_predicted.get_state_sequence()[0])

+5876:             best_action_fitness_predicted = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness']

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5876, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5876, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_13 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5876, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_fitness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5876, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __pyx_v_best_action_fitness_predicted = __pyx_t_3;
    __pyx_t_3 = 0;

+5877:             best_action_maneuver_tuple = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['maneuver_tuple']

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5877, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5877, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5877, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_maneuver_tuple); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5877, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_best_action_maneuver_tuple = __pyx_t_13;
    __pyx_t_13 = 0;

+5878:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5878, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5878, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (__pyx_t_2) {
/* … */
    }

+5879:                 assert game_state is not None and ship_state is not None  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_19 = (((PyObject *)__pyx_v_game_state) != Py_None);
        if (__pyx_t_19) {
        } else {
          __pyx_t_2 = __pyx_t_19;
          goto __pyx_L22_bool_binop_done;
        }
        __pyx_t_19 = (((PyObject *)__pyx_v_ship_state) != Py_None);
        __pyx_t_2 = __pyx_t_19;
        __pyx_L22_bool_binop_done:;
        if (unlikely(!__pyx_t_2)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5879, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5879, __pyx_L1_error)
      #endif

+5880:                 assert self.current_timestep == self.game_state_to_base_planning['timestep']  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5880, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5880, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5880, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyObject_RichCompare(__pyx_t_13, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5880, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5880, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_2)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5880, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5880, __pyx_L1_error)
      #endif

+5881:                 assert game_state is not None  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_2 = (((PyObject *)__pyx_v_game_state) != Py_None);
        if (unlikely(!__pyx_t_2)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5881, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5881, __pyx_L1_error)
      #endif

+5882:                 if not game_state.sim_frame == self.current_timestep:  # REMOVE_FOR_COMPETITION

      __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_game_state->sim_frame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5882, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5882, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5882, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5882, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_19 = (!__pyx_t_2);
      if (__pyx_t_19) {
      }

 5883:                     # print(self.current_timestep, game_state.sim_frame)  # REMOVE_FOR_COMPETITION

 5884:                     pass  # REMOVE_FOR_COMPETITION

+5885:                 assert game_state.sim_frame == self.current_timestep  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_13 = __Pyx_PyLong_From_int(__pyx_v_game_state->sim_frame); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5885, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5885, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_1 = PyObject_RichCompare(__pyx_t_13, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5885, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5885, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_19)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 5885, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 5885, __pyx_L1_error)
      #endif

+5886:             best_predicted_sim_fire_next_timestep_flag = best_action_sim_predicted.get_fire_next_timestep_flag()

    __pyx_t_3 = __pyx_v_best_action_sim_predicted;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fire_next_timestep_flag, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5886, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_best_predicted_sim_fire_next_timestep_flag = __pyx_t_1;
    __pyx_t_1 = 0;

 5887:             # debug_print(f"best_predicted_sim_fire_next_timestep_flag: {best_predicted_sim_fire_next_timestep_flag}, self.game_state_to_base_planning['fire_next_timestep_flag']: {self.game_state_to_base_planning['fire_next_timestep_flag']}")

 5888:             # self.game_state_to_base_planning['fire_next_timestep_flag'] is whether we fire at the BEGINNING of the period, while best_action_sim_predicted.get_fire_next_timestep_flag() is whether we fire AFTER this period

 5889:             # debug_print('DECIDE NEXT ACTION REDO sim ast pending death:')

 5890:             # debug_print(self.game_state_to_base_planning['asteroids_pending_death'])

 5891:             #print("Doing a best action sim")

+5892:             best_action_sim = Matrix(game_state=game_state,

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5892, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);

 5893:                                      ship_state=ship_state,

+5894:                                      initial_timestep=self.current_timestep,

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5894, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);

+5895:                                      respawn_timer=self.game_state_to_base_planning['ship_respawn_timer'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5895, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+5896:                                      asteroids_pending_death=self.game_state_to_base_planning['asteroids_pending_death'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+5897:                                      forecasted_asteroid_splits=self.game_state_to_base_planning['forecasted_asteroid_splits'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+5898:                                      last_timestep_fired=self.game_state_to_base_planning['last_timestep_fired'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5898, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5898, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+5899:                                      last_timestep_mined=self.game_state_to_base_planning['last_timestep_mined'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5899, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_20 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 5899, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+5900:                                      mine_positions_placed=self.game_state_to_base_planning['mine_positions_placed'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5900, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 5900, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+5901:                                      halt_shooting=self.game_state_to_base_planning['respawning'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5901, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_22 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 5901, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_22);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+5902:                                      fire_first_timestep=self.game_state_to_base_planning['fire_next_timestep_flag'],

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5902, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_23 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5902, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 5903:                                      verify_first_shot=True,

 5904:                                      verify_maneuver_shots=True,

+5905:                                      last_timestep_colliding=best_action_sim_predicted.get_last_timestep_colliding() if self.game_state_to_base_planning['respawning'] else -1,

    __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5905, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_24);
    __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_24, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5905, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5905, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    if (__pyx_t_19) {
      __pyx_t_24 = __pyx_v_best_action_sim_predicted;
      __Pyx_INCREF(__pyx_t_24);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_24, NULL};
        __pyx_t_25 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_last_timestep_colliding, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
        if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5905, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
      }
      __pyx_t_10 = __pyx_t_25;
      __pyx_t_25 = 0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
      __pyx_t_10 = __pyx_mstate_global->__pyx_int_neg_1;
    }

+5906:                                      game_state_plotter=self.game_state_plotter)

    __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5906, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_13))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_13);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 15 : 0)] = {__pyx_t_3, NULL};
      __pyx_t_24 = __Pyx_MakeVectorcallBuilderKwds(15); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5892, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, ((PyObject *)__pyx_v_game_state), __pyx_t_24, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, ((PyObject *)__pyx_v_ship_state), __pyx_t_24, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_t_5, __pyx_t_24, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_8, __pyx_t_24, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_4, __pyx_t_24, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_14, __pyx_t_24, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_12, __pyx_t_24, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_20, __pyx_t_24, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_21, __pyx_t_24, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_halt_shooting, __pyx_t_22, __pyx_t_24, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_t_23, __pyx_t_24, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_first_shot, Py_True, __pyx_t_24, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, Py_True, __pyx_t_24, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_colliding, __pyx_t_10, __pyx_t_24, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_t_25, __pyx_t_24, __pyx_callargs+1, 14) < 0) __PYX_ERR(0, 5892, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_13, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_24);
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5892, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_best_action_sim = __pyx_t_1;
    __pyx_t_1 = 0;

+5907:             best_action_sim_predicted_move_sequence = best_action_sim_predicted.get_intended_move_sequence()

    __pyx_t_13 = __pyx_v_best_action_sim_predicted;
    __Pyx_INCREF(__pyx_t_13);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_13, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_intended_move_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5907, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_best_action_sim_predicted_move_sequence = __pyx_t_1;
    __pyx_t_1 = 0;

+5908:             best_action_sim_actual_move_sequence = best_action_sim_predicted.get_move_sequence()

    __pyx_t_13 = __pyx_v_best_action_sim_predicted;
    __Pyx_INCREF(__pyx_t_13);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_13, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_move_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5908, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_best_action_sim_actual_move_sequence = __pyx_t_1;
    __pyx_t_1 = 0;

 5909:             #print(f"Actual move sequence length: {len(best_action_sim_actual_move_sequence)}, intended move sequence length: {len(best_action_sim_predicted_move_sequence)}")

 5910:             # If the actual move sequence is shorter than the intended, that's because I crashed into something. But we should still extend the shorter list with the rest of the elements of the intended move sequence, because just in case we don't collide as expected, the move sequence will still include the additional instructions needed to come to a complete stop again.

+5911:             if len(best_action_sim_predicted_move_sequence) > len(best_action_sim_actual_move_sequence):

    __pyx_t_6 = PyObject_Length(__pyx_v_best_action_sim_predicted_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5911, __pyx_L1_error)
    __pyx_t_15 = PyObject_Length(__pyx_v_best_action_sim_actual_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5911, __pyx_L1_error)
    __pyx_t_19 = (__pyx_t_6 > __pyx_t_15);
    if (__pyx_t_19) {
/* … */
    }

+5912:                 best_action_sim_actual_move_sequence.extend(best_action_sim_predicted_move_sequence[-(len(best_action_sim_predicted_move_sequence) - len(best_action_sim_actual_move_sequence)):])

      __pyx_t_13 = __pyx_v_best_action_sim_actual_move_sequence;
      __Pyx_INCREF(__pyx_t_13);
      __pyx_t_15 = PyObject_Length(__pyx_v_best_action_sim_predicted_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5912, __pyx_L1_error)
      __pyx_t_6 = PyObject_Length(__pyx_v_best_action_sim_actual_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5912, __pyx_L1_error)
      __pyx_t_24 = __Pyx_PyObject_GetSlice(__pyx_v_best_action_sim_predicted_move_sequence, (-(__pyx_t_15 - __pyx_t_6)), 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5912, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_24};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5912, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 5913:             #debug_print(f"\nIntended move sequence:")

 5914:             #debug_print(best_action_sim_predicted_move_sequence)

 5915:             #debug_print(f"Actual move sequence:")

 5916:             #debug_print(best_action_sim_actual_move_sequence)

 5917:             #print(f"Applying move sequence for maneuver. Seq is {best_action_sim_predicted_move_sequence}")

+5918:             if self.game_state_to_base_planning['respawning']:

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5918, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_24 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5918, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_24);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_24); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5918, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
    if (__pyx_t_19) {
/* … */
      goto __pyx_L26;
    }

 5919:                 #print("Applying respawning move sequence")

+5920:                 best_action_sim.apply_move_sequence(best_action_sim_actual_move_sequence, False, False)

      __pyx_t_1 = __pyx_v_best_action_sim;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_1, __pyx_v_best_action_sim_actual_move_sequence, Py_False, Py_False};
        __pyx_t_24 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_apply_move_sequence, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5920, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_24);
      }
      __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;

 5921:             else:

 5922:                 # This can only be maneuvering, and this gives the freedom to aim and shoot during the maneuver

 5923:                 #print(f'\ncalling sim maneuver in decide best with intended move sequence of {best_action_sim_predicted_move_sequence} and actual move sequence of {best_action_sim_predicted.get_move_sequence()}')

+5924:                 best_action_sim.simulate_maneuver(best_action_sim_actual_move_sequence, False, False) # TODO: Investigate. This completely takes out the shooting that we planned before!

    /*else*/ {
      __pyx_t_1 = __pyx_v_best_action_sim;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_1, __pyx_v_best_action_sim_actual_move_sequence, Py_False, Py_False};
        __pyx_t_24 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_simulate_maneuver, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5924, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_24);
      }
      __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
    }
    __pyx_L26:;

+5925:             best_action_sim.set_fire_next_timestep_flag(best_predicted_sim_fire_next_timestep_flag)

    __pyx_t_1 = __pyx_v_best_action_sim;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_best_predicted_sim_fire_next_timestep_flag};
      __pyx_t_24 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_fire_next_timestep_flag, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5925, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
    }
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;

 5926:             #print('crashing sim id:', best_action_sim.get_sim_id())

+5927:             best_action_fitness = best_action_sim.get_fitness()

    __pyx_t_1 = __pyx_v_best_action_sim;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
      __pyx_t_24 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5927, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
    }
    __pyx_v_best_action_fitness = __pyx_t_24;
    __pyx_t_24 = 0;

+5928:             best_action_fitness_breakdown = best_action_sim.get_fitness_breakdown()

    __pyx_t_1 = __pyx_v_best_action_sim;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
      __pyx_t_24 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness_breakdown, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5928, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
    }
    __pyx_v_best_action_fitness_breakdown = __pyx_t_24;
    __pyx_t_24 = 0;

 5929:             # debug_print(f"\nActual best action first state:", best_action_sim.get_state_sequence()[0])

+5930:             debug_print(f"\nUpdated simmed state. Old predicted fitness: {best_action_fitness_predicted}, new predicted fitness: {best_action_fitness}")

    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5930, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_25 = __Pyx_PyObject_FormatSimple(__pyx_v_best_action_fitness_predicted, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5930, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_best_action_fitness, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5930, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_26[0] = __pyx_mstate_global->__pyx_kp_u_Updated_simmed_state_Old_predic;
    __pyx_t_26[1] = __pyx_t_25;
    __pyx_t_26[2] = __pyx_mstate_global->__pyx_kp_u_new_predicted_fitness;
    __pyx_t_26[3] = __pyx_t_10;
    __pyx_t_23 = __Pyx_PyUnicode_Join(__pyx_t_26, 4, 46 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25) + 25 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
    if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5930, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_13))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_13);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_23};
      __pyx_t_24 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5930, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
    }
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;

+5931:             if best_action_fitness < best_action_fitness_predicted - 0.05:

    __pyx_t_24 = __Pyx_PyFloat_SubtractObjC(__pyx_v_best_action_fitness_predicted, __pyx_mstate_global->__pyx_float_0_05, 0.05, 0, 0); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5931, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_24);
    __pyx_t_13 = PyObject_RichCompare(__pyx_v_best_action_fitness, __pyx_t_24, Py_LT); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5931, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5931, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (__pyx_t_19) {
/* … */
    }

 5932:                 # Using the true current state, we see that our best sim's true fitness is lower than what we were expecting.

+5933:                 debug_print(f"\n\n\n\nDANGERRRRR!!!!! Updated simmed state. Old predicted fitness: {best_action_fitness_predicted}, new predicted fitness IS MUCH WORSE!!!!!!!: {best_action_fitness}")

      __pyx_t_24 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5933, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_best_action_fitness_predicted, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5933, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_best_action_fitness, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5933, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_26[0] = __pyx_mstate_global->__pyx_kp_u_DANGERRRRR_Updated_simmed_state;
      __pyx_t_26[1] = __pyx_t_1;
      __pyx_t_26[2] = __pyx_mstate_global->__pyx_kp_u_new_predicted_fitness_IS_MUCH_W;
      __pyx_t_26[3] = __pyx_t_10;
      __pyx_t_25 = __Pyx_PyUnicode_Join(__pyx_t_26, 4, 65 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 46 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
      if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5933, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_23))) {
        __pyx_t_24 = PyMethod_GET_SELF(__pyx_t_23);
        assert(__pyx_t_24);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
        __Pyx_INCREF(__pyx_t_24);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_24, __pyx_t_25};
        __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5933, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
      }
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+5934:                 debug_print("Old fitness breakdown:", self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness_breakdown'])

      __pyx_t_23 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5934, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5934, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5934, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_24, __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5934, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5934, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_25))) {
        __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_25);
        assert(__pyx_t_23);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_25);
        __Pyx_INCREF(__pyx_t_23);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_25, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_23, __pyx_mstate_global->__pyx_kp_u_Old_fitness_breakdown, __pyx_t_10};
        __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_25, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5934, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
      }
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

+5935:                 debug_print("New breakdown:", best_action_fitness_breakdown)

      __pyx_t_25 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5935, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_10))) {
        __pyx_t_25 = PyMethod_GET_SELF(__pyx_t_10);
        assert(__pyx_t_25);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
        __Pyx_INCREF(__pyx_t_25);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_25, __pyx_mstate_global->__pyx_kp_u_New_breakdown, __pyx_v_best_action_fitness_breakdown};
        __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5935, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
      }
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 5936:                 #print('Actual base state which is now current:')

 5937:                 #print(game_state)

 5938:                 #print('Actual ship state which is now current:')

 5939:                 #print(ship_state)

 5940:                 #print('And the NEW sim predicts the ship state to be:')

 5941:                 #print(best_action_sim.get_ship_state())

 5942:                 #print('But the old sim thought the ship state would be:')

 5943:                 #print(best_action_sim_predicted.get_ship_state())

+5944:                 if self.second_best_fitness_this_planning_period_index != INT_NEG_INF:

      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5944, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5944, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_25 = PyObject_RichCompare(__pyx_t_13, __pyx_t_10, Py_NE); __Pyx_XGOTREF(__pyx_t_25); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5944, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5944, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      if (__pyx_t_19) {
/* … */
      }

 5945:                     # The best action sim's reality is worse than expected. Try our second best as a backup and hopefully this will be better, and go according to plan!

+5946:                     if self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['state_type'] == 'predicted':

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5946, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5946, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_13 = __Pyx_PyObject_GetItem(__pyx_t_25, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5946, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_state_type); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5946, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_predicted, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5946, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (__pyx_t_19) {
/* … */
          goto __pyx_L29;
        }

 5947:                         # The second best sim also uses a predicted state

+5948:                         second_best_action_sim_predicted: Matrix = self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['sim']

          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5948, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5948, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_25 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5948, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5948, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __pyx_v_second_best_action_sim_predicted = __pyx_t_13;
          __pyx_t_13 = 0;

+5949:                         second_best_action_fitness_predicted = self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['fitness']

          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5949, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5949, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_t_13, __pyx_t_25); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5949, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_fitness); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5949, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __pyx_v_second_best_action_fitness_predicted = __pyx_t_25;
          __pyx_t_25 = 0;

+5950:                         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

          __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5950, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5950, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          if (__pyx_t_19) {
/* … */
          }

+5951:                             assert second_best_action_fitness_predicted == self.second_best_fitness_this_planning_period  # REMOVE_FOR_COMPETITION

            #ifndef CYTHON_WITHOUT_ASSERTIONS
            if (unlikely(__pyx_assertions_enabled())) {
              __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 5951, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_25);
              __pyx_t_10 = PyObject_RichCompare(__pyx_v_second_best_action_fitness_predicted, __pyx_t_25, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5951, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
              __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5951, __pyx_L1_error)
              __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
              if (unlikely(!__pyx_t_19)) {
                __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
                __PYX_ERR(0, 5951, __pyx_L1_error)
              }
            }
            #else
            if ((1)); else __PYX_ERR(0, 5951, __pyx_L1_error)
            #endif

+5952:                         second_best_predicted_sim_fire_next_timestep_flag = second_best_action_sim_predicted.get_fire_next_timestep_flag()

          __pyx_t_25 = __pyx_v_second_best_action_sim_predicted;
          __Pyx_INCREF(__pyx_t_25);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_25, NULL};
            __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fire_next_timestep_flag, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5952, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
          }
          __pyx_v_second_best_predicted_sim_fire_next_timestep_flag = __pyx_t_10;
          __pyx_t_10 = 0;

 5953:                         #print(f"Doing second best action sim. Ship respawn timer: {self.game_state_to_base_planning['ship_respawn_timer']}, asts pending death: {self.game_state_to_base_planning['asteroids_pending_death']}, forecasted splits: {self.game_state_to_base_planning['forecasted_asteroid_splits']}, is respawning: {self.game_state_to_base_planning['respawning']}, fire next ts flag: {self.game_state_to_base_planning['fire_next_timestep_flag']}")

+5954:                         second_best_action_sim = Matrix(game_state=game_state,

          __pyx_t_25 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5954, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);

 5955:                                                         ship_state=ship_state,

+5956:                                                         initial_timestep=self.current_timestep,

          __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 5956, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);

+5957:                                                         respawn_timer=self.game_state_to_base_planning['ship_respawn_timer'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5957, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_24 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 5957, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_24);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5958:                                                         asteroids_pending_death=self.game_state_to_base_planning['asteroids_pending_death'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5958, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_22 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 5958, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5959:                                                         forecasted_asteroid_splits=self.game_state_to_base_planning['forecasted_asteroid_splits'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5959, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 5959, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_21);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5960:                                                         last_timestep_fired=self.game_state_to_base_planning['last_timestep_fired'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5960, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_20 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 5960, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5961:                                                         last_timestep_mined=self.game_state_to_base_planning['last_timestep_mined'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5961, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5961, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_12);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5962:                                                         mine_positions_placed=self.game_state_to_base_planning['mine_positions_placed'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5962, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5962, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_14);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5963:                                                         halt_shooting=self.game_state_to_base_planning['respawning'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5963, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5963, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+5964:                                                         fire_first_timestep=self.game_state_to_base_planning['fire_next_timestep_flag'],

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5964, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5964, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 5965:                                                         verify_first_shot=True,

 5966:                                                         verify_maneuver_shots=True,

+5967:                                                         last_timestep_colliding=second_best_action_sim_predicted.get_last_timestep_colliding() if self.game_state_to_base_planning['respawning'] else -1,

          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5967, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5967, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5967, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (__pyx_t_19) {
            __pyx_t_5 = __pyx_v_second_best_action_sim_predicted;
            __Pyx_INCREF(__pyx_t_5);
            __pyx_t_9 = 0;
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
              __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_last_timestep_colliding, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
              if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5967, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_3);
            }
            __pyx_t_1 = __pyx_t_3;
            __pyx_t_3 = 0;
          } else {
            __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
            __pyx_t_1 = __pyx_mstate_global->__pyx_int_neg_1;
          }

+5968:                                                         game_state_plotter=self.game_state_plotter)

          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_9 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_13))) {
            __pyx_t_25 = PyMethod_GET_SELF(__pyx_t_13);
            assert(__pyx_t_25);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
            __Pyx_INCREF(__pyx_t_25);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
            __pyx_t_9 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 15 : 0)] = {__pyx_t_25, NULL};
            __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5954, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, ((PyObject *)__pyx_v_game_state), __pyx_t_5, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, ((PyObject *)__pyx_v_ship_state), __pyx_t_5, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_t_23, __pyx_t_5, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_24, __pyx_t_5, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_22, __pyx_t_5, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_21, __pyx_t_5, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_20, __pyx_t_5, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_12, __pyx_t_5, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_14, __pyx_t_5, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_halt_shooting, __pyx_t_4, __pyx_t_5, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_t_8, __pyx_t_5, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_first_shot, Py_True, __pyx_t_5, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, Py_True, __pyx_t_5, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_colliding, __pyx_t_1, __pyx_t_5, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_t_3, __pyx_t_5, __pyx_callargs+1, 14) < 0) __PYX_ERR(0, 5954, __pyx_L1_error)
            __pyx_t_10 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_13, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5);
            __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
            __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5954, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
          }
          __pyx_v_second_best_action_sim = __pyx_t_10;
          __pyx_t_10 = 0;

+5969:                         second_best_action_sim_predicted_move_sequence = second_best_action_sim_predicted.get_intended_move_sequence()

          __pyx_t_13 = __pyx_v_second_best_action_sim_predicted;
          __Pyx_INCREF(__pyx_t_13);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_13, NULL};
            __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_intended_move_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5969, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
          }
          __pyx_v_second_best_action_sim_predicted_move_sequence = __pyx_t_10;
          __pyx_t_10 = 0;

+5970:                         second_best_action_sim_actual_move_sequence = second_best_action_sim_predicted.get_move_sequence()

          __pyx_t_13 = __pyx_v_second_best_action_sim_predicted;
          __Pyx_INCREF(__pyx_t_13);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_13, NULL};
            __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_move_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5970, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
          }
          __pyx_v_second_best_action_sim_actual_move_sequence = __pyx_t_10;
          __pyx_t_10 = 0;

 5971:                         # If the actual move sequence is shorter than the intended, that's because I crashed into something. But we should still extend the shorter list with the rest of the elements of the intended move sequence, because just in case we don't collide as expected, the move sequence will still include the additional instructions needed to come to a complete stop again.

+5972:                         if len(second_best_action_sim_predicted_move_sequence) > len(second_best_action_sim_actual_move_sequence):

          __pyx_t_6 = PyObject_Length(__pyx_v_second_best_action_sim_predicted_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5972, __pyx_L1_error)
          __pyx_t_15 = PyObject_Length(__pyx_v_second_best_action_sim_actual_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5972, __pyx_L1_error)
          __pyx_t_19 = (__pyx_t_6 > __pyx_t_15);
          if (__pyx_t_19) {
/* … */
          }

+5973:                             second_best_action_sim_actual_move_sequence.extend(second_best_action_sim_predicted_move_sequence[-(len(second_best_action_sim_predicted_move_sequence) - len(second_best_action_sim_actual_move_sequence)):])

            __pyx_t_13 = __pyx_v_second_best_action_sim_actual_move_sequence;
            __Pyx_INCREF(__pyx_t_13);
            __pyx_t_15 = PyObject_Length(__pyx_v_second_best_action_sim_predicted_move_sequence); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5973, __pyx_L1_error)
            __pyx_t_6 = PyObject_Length(__pyx_v_second_best_action_sim_actual_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5973, __pyx_L1_error)
            __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_second_best_action_sim_predicted_move_sequence, (-(__pyx_t_15 - __pyx_t_6)), 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5973, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_9 = 0;
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_5};
              __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_extend, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
              if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5973, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_10);
            }
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 5974:                         # print(f"Applying move sequence for maneuver #2, seq is {second_best_action_sim_predicted_move_sequence}")

+5975:                         if self.game_state_to_base_planning['respawning']:

          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5975, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5975, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5975, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (__pyx_t_19) {
/* … */
            goto __pyx_L32;
          }

+5976:                             second_best_action_sim.apply_move_sequence(second_best_action_sim_actual_move_sequence, False, False)

            __pyx_t_10 = __pyx_v_second_best_action_sim;
            __Pyx_INCREF(__pyx_t_10);
            __pyx_t_9 = 0;
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_v_second_best_action_sim_actual_move_sequence, Py_False, Py_False};
              __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_apply_move_sequence, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
              if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5976, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
            }
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 5977:                         else:

 5978:                             # This can only be maneuvering, and this gives the freedom to aim and shoot during the maneuver

 5979:                             #print('calling sim maneuver in decide second best')  # REMOVE_FOR_COMPETITION

+5980:                             second_best_action_sim.simulate_maneuver(second_best_action_sim_actual_move_sequence, False, False)

          /*else*/ {
            __pyx_t_10 = __pyx_v_second_best_action_sim;
            __Pyx_INCREF(__pyx_t_10);
            __pyx_t_9 = 0;
            {
              PyObject *__pyx_callargs[4] = {__pyx_t_10, __pyx_v_second_best_action_sim_actual_move_sequence, Py_False, Py_False};
              __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_simulate_maneuver, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
              if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5980, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
            }
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          }
          __pyx_L32:;

+5981:                         second_best_action_sim.set_fire_next_timestep_flag(second_best_predicted_sim_fire_next_timestep_flag)

          __pyx_t_10 = __pyx_v_second_best_action_sim;
          __Pyx_INCREF(__pyx_t_10);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_v_second_best_predicted_sim_fire_next_timestep_flag};
            __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_fire_next_timestep_flag, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5981, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
          }
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+5982:                         second_best_action_fitness = second_best_action_sim.get_fitness()

          __pyx_t_10 = __pyx_v_second_best_action_sim;
          __Pyx_INCREF(__pyx_t_10);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
            __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5982, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
          }
          __pyx_v_second_best_action_fitness = __pyx_t_5;
          __pyx_t_5 = 0;

+5983:                         second_best_action_fitness_breakdown = second_best_action_sim.get_fitness_breakdown()

          __pyx_t_10 = __pyx_v_second_best_action_sim;
          __Pyx_INCREF(__pyx_t_10);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
            __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness_breakdown, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5983, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
          }
          __pyx_v_second_best_action_fitness_breakdown = __pyx_t_5;
          __pyx_t_5 = 0;

 5984:                     else:

 5985:                         # The second best sim uses an exact state

+5986:                         assert self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['state_type'] == 'exact'  # REMOVE_FOR_COMPETITION

        /*else*/ {
          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5986, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5986, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __pyx_t_13 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5986, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_state_type); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5986, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_10);
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_exact, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5986, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            if (unlikely(!__pyx_t_19)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 5986, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 5986, __pyx_L1_error)
          #endif

+5987:                         second_best_action_sim = self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['sim']

          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5987, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5987, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5987, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5987, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_v_second_best_action_sim = __pyx_t_13;
          __pyx_t_13 = 0;

+5988:                         second_best_action_fitness = self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['fitness']

          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5988, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5988, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_t_13, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5988, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_fitness); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5988, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __pyx_v_second_best_action_fitness = __pyx_t_5;
          __pyx_t_5 = 0;

+5989:                         second_best_action_fitness_breakdown = self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['fitness_breakdown']

          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5989, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5989, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_13 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5989, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5989, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __pyx_v_second_best_action_fitness_breakdown = __pyx_t_10;
          __pyx_t_10 = 0;
        }
        __pyx_L29:;

+5990:                     second_best_action_maneuver_tuple = self.sims_this_planning_period[self.second_best_fitness_this_planning_period_index]['maneuver_tuple']

        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5990, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5990, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5990, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_maneuver_tuple); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5990, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_v_second_best_action_maneuver_tuple = __pyx_t_13;
        __pyx_t_13 = 0;

+5991:                     if second_best_action_fitness > best_action_fitness and second_best_action_fitness >= second_best_action_fitness_predicted - 0.1:

        __pyx_t_13 = PyObject_RichCompare(__pyx_v_second_best_action_fitness, __pyx_v_best_action_fitness, Py_GT); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5991, __pyx_L1_error)
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5991, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (__pyx_t_2) {
        } else {
          __pyx_t_19 = __pyx_t_2;
          goto __pyx_L34_bool_binop_done;
        }
        if (unlikely(!__pyx_v_second_best_action_fitness_predicted)) { __Pyx_RaiseUnboundLocalError("second_best_action_fitness_predicted"); __PYX_ERR(0, 5991, __pyx_L1_error) }
        __pyx_t_13 = __Pyx_PyFloat_SubtractObjC(__pyx_v_second_best_action_fitness_predicted, __pyx_mstate_global->__pyx_float_0_1, 0.1, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5991, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_5 = PyObject_RichCompare(__pyx_v_second_best_action_fitness, __pyx_t_13, Py_GE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5991, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 5991, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_19 = __pyx_t_2;
        __pyx_L34_bool_binop_done:;
        if (__pyx_t_19) {
/* … */
          goto __pyx_L33;
        }

+5992:                         debug_print(f"HOORAY, the second best action's real fitness of {second_best_action_fitness} and predicted fitness of {second_best_action_fitness_predicted} is better than the best!")

          __pyx_t_13 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5992, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_second_best_action_fitness, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5992, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          if (unlikely(!__pyx_v_second_best_action_fitness_predicted)) { __Pyx_RaiseUnboundLocalError("second_best_action_fitness_predicted"); __PYX_ERR(0, 5992, __pyx_L1_error) }
          __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_second_best_action_fitness_predicted, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5992, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_27[0] = __pyx_mstate_global->__pyx_kp_u_HOORAY_the_second_best_action_s;
          __pyx_t_27[1] = __pyx_t_3;
          __pyx_t_27[2] = __pyx_mstate_global->__pyx_kp_u_and_predicted_fitness_of;
          __pyx_t_27[3] = __pyx_t_1;
          __pyx_t_27[4] = __pyx_mstate_global->__pyx_kp_u_is_better_than_the_best;
          __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_27, 5, 49 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 26 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 25, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1));
          if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5992, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_9 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_10))) {
            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_10);
            assert(__pyx_t_13);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
            __Pyx_INCREF(__pyx_t_13);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
            __pyx_t_9 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_8};
            __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5992, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
          }
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+5993:                         best_action_fitness = second_best_action_fitness

          __Pyx_INCREF(__pyx_v_second_best_action_fitness);
          __Pyx_DECREF_SET(__pyx_v_best_action_fitness, __pyx_v_second_best_action_fitness);

+5994:                         best_action_sim = second_best_action_sim

          __Pyx_INCREF(__pyx_v_second_best_action_sim);
          __Pyx_DECREF_SET(__pyx_v_best_action_sim, __pyx_v_second_best_action_sim);

+5995:                         best_action_fitness_breakdown = second_best_action_fitness_breakdown

          __Pyx_INCREF(__pyx_v_second_best_action_fitness_breakdown);
          __Pyx_DECREF_SET(__pyx_v_best_action_fitness_breakdown, __pyx_v_second_best_action_fitness_breakdown);

+5996:                         best_action_maneuver_tuple = second_best_action_maneuver_tuple

          __Pyx_INCREF(__pyx_v_second_best_action_maneuver_tuple);
          __Pyx_DECREF_SET(__pyx_v_best_action_maneuver_tuple, __pyx_v_second_best_action_maneuver_tuple);

 5997:                     else:

+5998:                         debug_print(f"CRAP, even the second best action's real fitness of {second_best_action_fitness} and predicted fitness of {second_best_action_fitness_predicted} isn't better than the first, so we'll just have to go with what we have and maybe get screwed.")

        /*else*/ {
          __pyx_t_10 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5998, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_second_best_action_fitness, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5998, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          if (unlikely(!__pyx_v_second_best_action_fitness_predicted)) { __Pyx_RaiseUnboundLocalError("second_best_action_fitness_predicted"); __PYX_ERR(0, 5998, __pyx_L1_error) }
          __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_second_best_action_fitness_predicted, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5998, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_27[0] = __pyx_mstate_global->__pyx_kp_u_CRAP_even_the_second_best_action;
          __pyx_t_27[1] = __pyx_t_13;
          __pyx_t_27[2] = __pyx_mstate_global->__pyx_kp_u_and_predicted_fitness_of;
          __pyx_t_27[3] = __pyx_t_1;
          __pyx_t_27[4] = __pyx_mstate_global->__pyx_kp_u_isn_t_better_than_the_first_so;
          __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_27, 5, 52 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13) + 26 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 95, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_13) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1));
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5998, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_9 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_8))) {
            __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8);
            assert(__pyx_t_10);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
            __Pyx_INCREF(__pyx_t_10);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
            __pyx_t_9 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_3};
            __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5998, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
          }
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 5999:                         # Go back to the drawing board and do more simulations to find a good one! This will lag the game a bit, but it's better to slightly lag the game and put on a better show than to die.

 6000:                         # Flush out the bad sims that the top spots are polluted with.

+6001:                         self.sims_this_planning_period.clear()

          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6001, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_8 = __pyx_t_3;
          __Pyx_INCREF(__pyx_t_8);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
            __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6001, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
          }
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6002:                         self.best_fitness_this_planning_period = -INFINITY

          __pyx_t_5 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6002, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_t_5) < 0) __PYX_ERR(0, 6002, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6003:                         self.best_fitness_this_planning_period_index = INT_NEG_INF

          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6003, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_5) < 0) __PYX_ERR(0, 6003, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6004:                         self.second_best_fitness_this_planning_period = -INFINITY

          __pyx_t_5 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6004, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_5) < 0) __PYX_ERR(0, 6004, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6005:                         self.second_best_fitness_this_planning_period_index = INT_NEG_INF

          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6005, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_5) < 0) __PYX_ERR(0, 6005, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6006:                         self.stationary_targetting_sim_index = INT_NEG_INF

          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6006, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index, __pyx_t_5) < 0) __PYX_ERR(0, 6006, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6007:                         return False

          __Pyx_XDECREF(__pyx_r);
          __Pyx_INCREF(Py_False);
          __pyx_r = Py_False;
          goto __pyx_L0;
        }
        __pyx_L33:;

 6008: 

+6009:             if self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['action_type'] == 'targetting':  # REMOVE_FOR_COMPETITION

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6009, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6009, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6009, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_action_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6009, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_targetting, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6009, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(__pyx_t_19)) {
/* … */
    }

 6010:                 # The targetting sim was done with the true state, so this should be the exact same and redundant  # REMOVE_FOR_COMPETITION

+6011:                 raise Exception("WHY THE HECK ARE WE IN HERE?!!")  # REMOVE_FOR_COMPETITION

      __pyx_t_8 = NULL;
      __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
      __pyx_t_5 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
      __pyx_t_9 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_WHY_THE_HECK_ARE_WE_IN_HERE};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6011, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(0, 6011, __pyx_L1_error)

 6012:         else:

 6013:             # The state we based planning off of is exact

+6014:             assert self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['state_type'] == 'exact'  # REMOVE_FOR_COMPETITION

  /*else*/ {
    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6014, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6014, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6014, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_state_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6014, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_exact, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6014, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_19)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 6014, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 6014, __pyx_L1_error)
    #endif

+6015:             if self.game_state_to_base_planning['respawning']:

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6015, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6015, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6015, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_19) {
/* … */
      goto __pyx_L37;
    }

 6016:                 # If we did a respawn maneuver, we still have to run a second pass of it so we can get more shots in at the end, and hopefully eek out a bit more fitness score

+6017:                 best_action_sim_respawn_first_pass: Matrix = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['sim']

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6017, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6017, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6017, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6017, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_v_best_action_sim_respawn_first_pass = __pyx_t_5;
      __pyx_t_5 = 0;

+6018:                 best_action_sim_respawn_first_pass_fitness: float = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness']

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6018, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6018, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6018, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_fitness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6018, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_28 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_28 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 6018, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_v_best_action_sim_respawn_first_pass_fitness = __pyx_t_28;

+6019:                 best_respawn_first_pass_sim_fire_next_timestep_flag = best_action_sim_respawn_first_pass.get_fire_next_timestep_flag()

      __pyx_t_8 = __pyx_v_best_action_sim_respawn_first_pass;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fire_next_timestep_flag, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6019, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_v_best_respawn_first_pass_sim_fire_next_timestep_flag = __pyx_t_3;
      __pyx_t_3 = 0;

 6020:                 #print(f"RUNNING SECOND PASS OF RESPAWN MANEUVER. {best_action_sim_respawn_first_pass.get_last_timestep_colliding_with_asteroid()=}")

+6021:                 best_action_sim = Matrix(game_state=game_state,

      __pyx_t_8 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6021, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);

 6022:                                          ship_state=ship_state,

+6023:                                          initial_timestep=self.current_timestep,

      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6023, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);

+6024:                                          respawn_timer=self.game_state_to_base_planning['ship_respawn_timer'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6024, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_13 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 6024, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6025:                                          asteroids_pending_death=self.game_state_to_base_planning['asteroids_pending_death'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6025, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6025, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6026:                                          forecasted_asteroid_splits=self.game_state_to_base_planning['forecasted_asteroid_splits'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6026, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6026, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6027:                                          last_timestep_fired=self.game_state_to_base_planning['last_timestep_fired'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6027, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_12 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 6027, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6028:                                          last_timestep_mined=self.game_state_to_base_planning['last_timestep_mined'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6028, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_20 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6028, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6029:                                          mine_positions_placed=self.game_state_to_base_planning['mine_positions_placed'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6029, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6029, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6030:                                          halt_shooting=self.game_state_to_base_planning['respawning'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6030, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_22 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6030, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6031:                                          fire_first_timestep=self.game_state_to_base_planning['fire_next_timestep_flag'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6031, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_24 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 6031, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6032:                                          verify_first_shot=True,

 6033:                                          verify_maneuver_shots=True,

+6034:                                          last_timestep_colliding=best_action_sim_respawn_first_pass.get_last_timestep_colliding(), # This is the secret sauce!

      __pyx_t_23 = __pyx_v_best_action_sim_respawn_first_pass;
      __Pyx_INCREF(__pyx_t_23);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_23, NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_last_timestep_colliding, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6034, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }

+6035:                                          game_state_plotter=self.game_state_plotter)

      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6035, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_8);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 15 : 0)] = {__pyx_t_8, NULL};
        __pyx_t_25 = __Pyx_MakeVectorcallBuilderKwds(15); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6021, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, ((PyObject *)__pyx_v_game_state), __pyx_t_25, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, ((PyObject *)__pyx_v_ship_state), __pyx_t_25, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_t_10, __pyx_t_25, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_13, __pyx_t_25, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_4, __pyx_t_25, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_14, __pyx_t_25, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_12, __pyx_t_25, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_20, __pyx_t_25, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_21, __pyx_t_25, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_halt_shooting, __pyx_t_22, __pyx_t_25, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_t_24, __pyx_t_25, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_first_shot, Py_True, __pyx_t_25, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, Py_True, __pyx_t_25, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_colliding, __pyx_t_1, __pyx_t_25, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_t_23, __pyx_t_25, __pyx_callargs+1, 14) < 0) __PYX_ERR(0, 6021, __pyx_L1_error)
        __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_25);
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6021, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_v_best_action_sim = __pyx_t_3;
      __pyx_t_3 = 0;

+6036:                 best_action_sim_respawn_first_pass_move_sequence = best_action_sim_respawn_first_pass.get_intended_move_sequence()

      __pyx_t_5 = __pyx_v_best_action_sim_respawn_first_pass;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_intended_move_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6036, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_v_best_action_sim_respawn_first_pass_move_sequence = __pyx_t_3;
      __pyx_t_3 = 0;

+6037:                 best_action_sim.apply_move_sequence(best_action_sim_respawn_first_pass_move_sequence, True)

      __pyx_t_5 = __pyx_v_best_action_sim;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_best_action_sim_respawn_first_pass_move_sequence, Py_True};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_apply_move_sequence, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6037, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6038:                 best_action_sim.set_fire_next_timestep_flag(best_respawn_first_pass_sim_fire_next_timestep_flag)

      __pyx_t_5 = __pyx_v_best_action_sim;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_best_respawn_first_pass_sim_fire_next_timestep_flag};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_fire_next_timestep_flag, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6038, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6039:                 best_action_fitness = best_action_sim.get_fitness()

      __pyx_t_5 = __pyx_v_best_action_sim;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6039, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_v_best_action_fitness = __pyx_t_3;
      __pyx_t_3 = 0;

+6040:                 best_action_fitness_breakdown = best_action_sim.get_fitness_breakdown()

      __pyx_t_5 = __pyx_v_best_action_sim;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness_breakdown, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6040, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_v_best_action_fitness_breakdown = __pyx_t_3;
      __pyx_t_3 = 0;

+6041:                 best_action_maneuver_tuple = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['maneuver_tuple']

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6041, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6041, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_25 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6041, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_maneuver_tuple); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6041, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_v_best_action_maneuver_tuple = __pyx_t_5;
      __pyx_t_5 = 0;

 6042:                 #print(f"First pass fitness: {best_action_sim_respawn_first_pass_fitness}, second pass fitness: {best_action_fitness}, first pass breakdown: {self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness_breakdown']}, second pass breakdown: {best_action_fitness_breakdown}")  # REMOVE_FOR_COMPETITION

+6043:                 if best_action_sim_respawn_first_pass_fitness > best_action_fitness + 0.015:

      __pyx_t_5 = PyFloat_FromDouble(__pyx_v_best_action_sim_respawn_first_pass_fitness); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6043, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_25 = __Pyx_PyFloat_AddObjC(__pyx_v_best_action_fitness, __pyx_mstate_global->__pyx_float_0_015, 0.015, 0, 0); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6043, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_25, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6043, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6043, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_19) {
/* … */
      }

 6044:                     #print("REVERTING TO FIRST PASS. SECOND PASS DIDN'T HELP!")  # REMOVE_FOR_COMPETITION

 6045:                     # The additional shots didn't actually help our fitness. Reverting to just using the first pass sim which is totally valid still

+6046:                     best_action_sim = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['sim']

        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6046, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6046, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_25); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6046, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6046, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF_SET(__pyx_v_best_action_sim, __pyx_t_25);
        __pyx_t_25 = 0;

+6047:                     best_action_fitness = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness']

        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6047, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6047, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_25, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6047, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_fitness); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6047, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_best_action_fitness, __pyx_t_5);
        __pyx_t_5 = 0;

+6048:                     best_action_fitness_breakdown = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness_breakdown']

        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6048, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6048, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_25 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6048, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6048, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF_SET(__pyx_v_best_action_fitness_breakdown, __pyx_t_3);
        __pyx_t_3 = 0;

+6049:                     best_action_maneuver_tuple = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['maneuver_tuple']

        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6049, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6049, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_25); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6049, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_maneuver_tuple); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6049, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF_SET(__pyx_v_best_action_maneuver_tuple, __pyx_t_25);
        __pyx_t_25 = 0;

 6050:             else:

 6051:                 # Exact planning, and this isn't a respawn maneuver so we just do the one-pass simulation method and call it a day

+6052:                 best_action_sim = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['sim']

    /*else*/ {
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6052, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6052, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_25, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6052, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6052, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_v_best_action_sim = __pyx_t_5;
      __pyx_t_5 = 0;

+6053:                 best_action_fitness = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness']

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6053, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6053, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_25 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6053, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_fitness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6053, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_v_best_action_fitness = __pyx_t_3;
      __pyx_t_3 = 0;

+6054:                 best_action_fitness_breakdown = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness_breakdown']

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6054, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6054, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_25); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6054, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6054, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_v_best_action_fitness_breakdown = __pyx_t_25;
      __pyx_t_25 = 0;

+6055:                 best_action_maneuver_tuple = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['maneuver_tuple']

      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6055, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6055, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_25, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6055, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_maneuver_tuple); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6055, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_v_best_action_maneuver_tuple = __pyx_t_5;
      __pyx_t_5 = 0;
    }
    __pyx_L37:;
  }
  __pyx_L20:;

+6056:         if best_action_maneuver_tuple is not None and not self.game_state_to_base_planning['respawning'] and best_action_fitness_breakdown[5] != 0.0:

  __pyx_t_2 = (__pyx_v_best_action_maneuver_tuple != Py_None);
  if (__pyx_t_2) {
  } else {
    __pyx_t_19 = __pyx_t_2;
    goto __pyx_L40_bool_binop_done;
  }
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6056, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_29 = (!__pyx_t_2);
  if (__pyx_t_29) {
  } else {
    __pyx_t_19 = __pyx_t_29;
    goto __pyx_L40_bool_binop_done;
  }
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_best_action_fitness_breakdown, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_29 = (__Pyx_PyFloat_BoolNeObjC(__pyx_t_3, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6056, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_19 = __pyx_t_29;
  __pyx_L40_bool_binop_done:;
  if (__pyx_t_19) {
/* … */
  }

 6057:             # This is either a heuristic or random maneuver

 6058:             #global total_abs_cruise_speed, total_cruise_timesteps, total_maneuvers_to_learn_from

 6059:             #total_abs_cruise_speed += abs(best_action_maneuver_tuple[1])

 6060:             #total_cruise_timesteps += best_action_maneuver_tuple[3]

 6061:             #total_maneuvers_to_learn_from += 1

 6062:             global abs_cruise_speeds, cruise_timesteps

+6063:             abs_cruise_speeds.append(abs(best_action_maneuver_tuple[1]))

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_abs_cruise_speeds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6063, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_best_action_maneuver_tuple, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6063, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_25 = __Pyx_PyNumber_Absolute(__pyx_t_5); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6063, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_17 = __Pyx_PyObject_Append(__pyx_t_3, __pyx_t_25); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 6063, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;

+6064:             cruise_timesteps.append(best_action_maneuver_tuple[3])

    __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_cruise_timesteps); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6064, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_best_action_maneuver_tuple, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6064, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_17 = __Pyx_PyObject_Append(__pyx_t_25, __pyx_t_3); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 6064, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6065:             if len(abs_cruise_speeds) > MANEUVER_TUPLE_LEARNING_ROLLING_AVERAGE_PERIOD:

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_abs_cruise_speeds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6065, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6065, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6065, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_MANEUVER_TUPLE_LEARNING_ROLLING); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6065, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_25, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6065, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6065, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_19) {
/* … */
    }

+6066:                 abs_cruise_speeds = abs_cruise_speeds[-MANEUVER_TUPLE_LEARNING_ROLLING_AVERAGE_PERIOD:]

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_abs_cruise_speeds); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_MANEUVER_TUPLE_LEARNING_ROLLING); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_3 = PyNumber_Negative(__pyx_t_25); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, 0, &__pyx_t_3, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6066, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_abs_cruise_speeds, __pyx_t_25) < 0) __PYX_ERR(0, 6066, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;

+6067:             if len(cruise_timesteps) > MANEUVER_TUPLE_LEARNING_ROLLING_AVERAGE_PERIOD:

    __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_cruise_timesteps); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6067, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_6 = PyObject_Length(__pyx_t_25); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6067, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_25 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6067, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MANEUVER_TUPLE_LEARNING_ROLLING); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6067, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_25, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6067, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6067, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_19) {
/* … */
    }

+6068:                 cruise_timesteps = cruise_timesteps[-MANEUVER_TUPLE_LEARNING_ROLLING_AVERAGE_PERIOD:]

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_cruise_timesteps); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6068, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MANEUVER_TUPLE_LEARNING_ROLLING); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6068, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_25 = PyNumber_Negative(__pyx_t_3); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6068, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, 0, &__pyx_t_25, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6068, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_cruise_timesteps, __pyx_t_3) < 0) __PYX_ERR(0, 6068, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 6069:             #print(f"{best_action_maneuver_tuple=}, and the avg best cruise speed is now {weighted_average(abs_cruise_speeds)} and avg cruise timesteps is {weighted_average(cruise_timesteps)}")

 6070:         # Maintain a rolling average of the overall fitnesses, so we know how well we're doing

 6071:         global overall_fitness_record

+6072:         overall_fitness_record.append(best_action_fitness)

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6072, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_17 = __Pyx_PyObject_Append(__pyx_t_3, __pyx_v_best_action_fitness); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 6072, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6073:         if len(overall_fitness_record) > OVERALL_FITNESS_ROLLING_AVERAGE_PERIOD:

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6073, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_OVERALL_FITNESS_ROLLING_AVERAGE); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_25, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6073, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
  __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6073, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_19) {
/* … */
  }

+6074:             overall_fitness_record = overall_fitness_record[-OVERALL_FITNESS_ROLLING_AVERAGE_PERIOD:]

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6074, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_OVERALL_FITNESS_ROLLING_AVERAGE); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6074, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_3 = PyNumber_Negative(__pyx_t_25); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6074, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_25 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, 0, &__pyx_t_3, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6074, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_overall_fitness_record, __pyx_t_25) < 0) __PYX_ERR(0, 6074, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;

 6075: 

+6076:         if PRINT_EXPLANATIONS:

  __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_PRINT_EXPLANATIONS); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6076, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_25); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6076, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
  if (__pyx_t_19) {
/* … */
  }

 6077:             # Print out the explanation messages that were stored within the sim

+6078:             if self.stationary_targetting_sim_index != INT_NEG_INF:

    __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6078, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6078, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyObject_RichCompare(__pyx_t_25, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6078, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6078, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_19) {
/* … */
    }

+6079:                 stationary_safety_messages: list[str] = self.sims_this_planning_period[self.stationary_targetting_sim_index]['sim'].get_safety_messages()

      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6079, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6079, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_25, __pyx_t_23); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6079, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __pyx_t_23 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_sim); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6079, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_3 = __pyx_t_23;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_safety_messages, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6079, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_5))) __PYX_ERR(0, 6079, __pyx_L1_error)
      __pyx_v_stationary_safety_messages = ((PyObject*)__pyx_t_5);
      __pyx_t_5 = 0;

+6080:                 for message in stationary_safety_messages:

      if (unlikely(__pyx_v_stationary_safety_messages == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
        __PYX_ERR(0, 6080, __pyx_L1_error)
      }
      __pyx_t_5 = __pyx_v_stationary_safety_messages; __Pyx_INCREF(__pyx_t_5);
      __pyx_t_6 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6080, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        __pyx_t_23 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_6);
        ++__pyx_t_6;
        if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6080, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_XDECREF_SET(__pyx_v_message, __pyx_t_23);
        __pyx_t_23 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6081:                     print_explanation(message, self.current_timestep)

        __pyx_t_3 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6081, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6081, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __pyx_t_9 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_1))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
          __pyx_t_9 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_message, __pyx_t_25};
          __pyx_t_23 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6081, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
        }
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;

 6082: 

 6083:             # if best_action_fitness <= 0.1:

+6084:             if best_action_fitness_breakdown[5] == 0.0:

    __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_best_action_fitness_breakdown, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6084, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_19 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_5, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6084, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_19) {
/* … */
    }

 6085:                 # We're gonna die. Force select the one where I stay put and accept my fate, and don't even begin a maneuver.

+6086:                 print_explanation("RIP, I'm gonna die", self.current_timestep)

      __pyx_t_23 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6086, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6086, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_1))) {
        __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_1);
        assert(__pyx_t_23);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_23);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_23, __pyx_mstate_global->__pyx_kp_u_RIP_I_m_gonna_die, __pyx_t_25};
        __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6086, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 6087:                 #print('IT LOOKS LIKE THIS NEW ACTION WE ARE DOING ENDS IN DEATH!!!')

 6088:                 # if self.stationary_targetting_sim_index:

 6089:                 #    self.best_fitness_this_planning_period_index = self.stationary_targetting_sim_index

 6090:                 #    best_action_sim: Simulation = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['sim']

 6091:                 #    best_action_fitness = self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness']

+6092:             if self.game_state_to_base_planning['respawning']:

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6092, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6092, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6092, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_19) {
/* … */
    }

+6093:                 print_explanation(f"Doing a respawn maneuver to get to a safe spot using my respawn invincibility. This maneuver was the best one picked out of {len(self.sims_this_planning_period)} randomly chosen maneuvers!", self.current_timestep)

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6093, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6093, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_6 = PyObject_Length(__pyx_t_23); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6093, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __pyx_t_23 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_6, 0, ' ', 'd'); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6093, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Doing_a_respawn_maneuver_to_get;
      __pyx_t_7[1] = __pyx_t_23;
      __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_randomly_chosen_maneuvers;
      __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 124 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_23) + 27, 127);
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6093, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6093, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_25))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_25);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_25);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_25, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_23};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_25, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6093, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6094:             if self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['action_type'] in ['random_maneuver', 'heuristic_maneuver']:

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6094, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6094, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_25); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6094, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_action_type); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6094, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_25);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_29 = (__Pyx_PyUnicode_Equals(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_random_maneuver, Py_EQ)); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6094, __pyx_L1_error)
    if (!__pyx_t_29) {
    } else {
      __pyx_t_19 = __pyx_t_29;
      goto __pyx_L54_bool_binop_done;
    }
    __pyx_t_29 = (__Pyx_PyUnicode_Equals(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_heuristic_maneuver, Py_EQ)); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6094, __pyx_L1_error)
    __pyx_t_19 = __pyx_t_29;
    __pyx_L54_bool_binop_done:;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    __pyx_t_29 = __pyx_t_19;
    if (__pyx_t_29) {
/* … */
    }

 6095:                 # [asteroid_safe_time_fitness, mine_safe_time_fitness, asteroids_fitness, sequence_length_fitness, other_ship_proximity_fitness, crash_fitness, asteroid_aiming_cone_fitness]

 6096:                 #if self.stationary_targetting_sim_index is None:

 6097:                     #print(f"WARNING: There are no stationary targetting sims!")

+6098:                 if self.stationary_targetting_sim_index != INT_NEG_INF:

      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6098, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6098, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_1 = PyObject_RichCompare(__pyx_t_25, __pyx_t_23, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6098, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6098, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__pyx_t_29) {
/* … */
      }

+6099:                     stationary_fitness_breakdown = self.sims_this_planning_period[self.stationary_targetting_sim_index]['fitness_breakdown']

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6099, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6099, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_25 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_23); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6099, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_23 = __Pyx_PyObject_Dict_GetItem(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6099, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __pyx_v_stationary_fitness_breakdown = __pyx_t_23;
        __pyx_t_23 = 0;

 6100:                     # debug_print('stationary fitneses', stationary_fitness_breakdown)

 6101:                     #print(f"Stationary breakdown: {stationary_fitness_breakdown}, best sim breakdown: {best_action_fitness_breakdown}")

+6102:                     if best_action_fitness_breakdown[1] == 1.0 and stationary_fitness_breakdown[1] == 1.0:

        __pyx_t_23 = __Pyx_GetItemInt(__pyx_v_best_action_fitness_breakdown, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6102, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_19 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_23, __pyx_mstate_global->__pyx_float_1_0, 1.0, 0, 0)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6102, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (__pyx_t_19) {
        } else {
          __pyx_t_29 = __pyx_t_19;
          goto __pyx_L58_bool_binop_done;
        }
        __pyx_t_23 = __Pyx_GetItemInt(__pyx_v_stationary_fitness_breakdown, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6102, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_19 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_23, __pyx_mstate_global->__pyx_float_1_0, 1.0, 0, 0)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6102, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_29 = __pyx_t_19;
        __pyx_L58_bool_binop_done:;
        if (__pyx_t_29) {
/* … */
          goto __pyx_L57;
        }

 6103:                         # No mines are threatening us whether we stay put or move

+6104:                         if best_action_fitness_breakdown[0] > stationary_fitness_breakdown[0]:

          __pyx_t_23 = __Pyx_GetItemInt(__pyx_v_best_action_fitness_breakdown, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6104, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __pyx_t_25 = __Pyx_GetItemInt(__pyx_v_stationary_fitness_breakdown, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6104, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_1 = PyObject_RichCompare(__pyx_t_23, __pyx_t_25, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6104, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6104, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (__pyx_t_29) {
/* … */
          }

+6105:                             print_explanation(f"Doing a maneuver to dodge asteroids! This maneuver was the best one picked out of {len(self.sims_this_planning_period)} randomly chosen maneuvers!", self.current_timestep)

            __pyx_t_25 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6105, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_23);
            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6105, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6105, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_6, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6105, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Doing_a_maneuver_to_dodge_astero;
            __pyx_t_7[1] = __pyx_t_3;
            __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_randomly_chosen_maneuvers;
            __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 82 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 27, 127);
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6105, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6105, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_9 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_23))) {
              __pyx_t_25 = PyMethod_GET_SELF(__pyx_t_23);
              assert(__pyx_t_25);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23);
              __Pyx_INCREF(__pyx_t_25);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_23, __pyx__function);
              __pyx_t_9 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_25, __pyx_t_5, __pyx_t_3};
              __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
              if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6105, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
            }
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6106:                     elif best_action_fitness_breakdown[1] > stationary_fitness_breakdown[1]:

        __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_best_action_fitness_breakdown, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6106, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_23 = __Pyx_GetItemInt(__pyx_v_stationary_fitness_breakdown, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6106, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_23, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6106, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6106, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (__pyx_t_29) {
/* … */
        }
        __pyx_L57:;

+6107:                         print_explanation(f"Doing a maneuver to dodge a mine! This maneuver was the best one picked out of {len(self.sims_this_planning_period)} randomly chosen maneuvers!", self.current_timestep)

          __pyx_t_23 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6107, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6107, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6107, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_6, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6107, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Doing_a_maneuver_to_dodge_a_mine;
          __pyx_t_7[1] = __pyx_t_5;
          __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_randomly_chosen_maneuvers;
          __pyx_t_25 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 79 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 27, 127);
          if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6107, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6107, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_9 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_1))) {
            __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_1);
            assert(__pyx_t_23);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
            __Pyx_INCREF(__pyx_t_23);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
            __pyx_t_9 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_23, __pyx_t_25, __pyx_t_5};
            __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6107, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6108:                     if best_action_fitness_breakdown[4] > stationary_fitness_breakdown[4] + 0.05:

        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_best_action_fitness_breakdown, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6108, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_stationary_fitness_breakdown, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6108, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_5 = __Pyx_PyFloat_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_float_0_05, 0.05, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6108, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6108, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6108, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (__pyx_t_29) {
/* … */
        }

+6109:                         print_explanation(f"Doing a maneuver to get away from the other ship! This maneuver was the best one picked out of {len(self.sims_this_planning_period)} randomly chosen maneuvers!", self.current_timestep)

          __pyx_t_5 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6109, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6109, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_6 = PyObject_Length(__pyx_t_25); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6109, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __pyx_t_25 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_6, 0, ' ', 'd'); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6109, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Doing_a_maneuver_to_get_away_fro;
          __pyx_t_7[1] = __pyx_t_25;
          __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_randomly_chosen_maneuvers;
          __pyx_t_23 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 95 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25) + 27, 127);
          if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6109, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_23);
          __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
          __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6109, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_25);
          __pyx_t_9 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_3))) {
            __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
            assert(__pyx_t_5);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
            __Pyx_INCREF(__pyx_t_5);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
            __pyx_t_9 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_23, __pyx_t_25};
            __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
            __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6109, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
          }
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6110:         best_move_sequence = best_action_sim.get_move_sequence()

  __pyx_t_3 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_move_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6110, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_best_move_sequence = __pyx_t_1;
  __pyx_t_1 = 0;

+6111:         debug_print(f"Best sim ID: {best_action_sim.get_sim_id()}, with index {self.best_fitness_this_planning_period_index} and fitness {best_action_fitness} breakdown: {best_action_fitness_breakdown} and length {len(best_move_sequence)}")#, move seq: {best_move_sequence}")

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_25);
  __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_best_action_sim, __pyx_mstate_global->__pyx_n_u_get_sim_id); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_23); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
  __pyx_t_23 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_24 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_24);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_best_action_fitness, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_22 = __Pyx_PyObject_FormatSimple(__pyx_v_best_action_fitness_breakdown, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_6 = PyObject_Length(__pyx_v_best_move_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6111, __pyx_L1_error)
  __pyx_t_21 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_6, 0, ' ', 'd'); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __pyx_t_30[0] = __pyx_mstate_global->__pyx_kp_u_Best_sim_ID;
  __pyx_t_30[1] = __pyx_t_23;
  __pyx_t_30[2] = __pyx_mstate_global->__pyx_kp_u_with_index;
  __pyx_t_30[3] = __pyx_t_24;
  __pyx_t_30[4] = __pyx_mstate_global->__pyx_kp_u_and_fitness;
  __pyx_t_30[5] = __pyx_t_5;
  __pyx_t_30[6] = __pyx_mstate_global->__pyx_kp_u_breakdown;
  __pyx_t_30[7] = __pyx_t_22;
  __pyx_t_30[8] = __pyx_mstate_global->__pyx_kp_u_and_length;
  __pyx_t_30[9] = __pyx_t_21;
  __pyx_t_20 = __Pyx_PyUnicode_Join(__pyx_t_30, 10, 13 * 3 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_23) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_24) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 12 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_22) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_21), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_23) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_24) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_22));
  if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
  __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_25))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_25);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_25);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_25, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_20};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_25, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6111, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6112:         #print(f"Current average overall fitness is {weighted_average(overall_fitness_record)}")

 6113:         # debug_print(f"Respawn maneuver status is: {self.game_state_to_base_planning['respawning']}, Move type: {self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['action_type']}, state type: {self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['state_type']}, Best move seq with fitness {best_action_fitness}: {best_move_sequence}")

+6114:         best_action_sim_state_sequence = best_action_sim.get_state_sequence()

  __pyx_t_25 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_25);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_25, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_state_sequence, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6114, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_best_action_sim_state_sequence = __pyx_t_1;
  __pyx_t_1 = 0;

 6115:         # debug_print(f"The action we're taking is from timestep {best_action_sim_state_sequence[0]['timestep']} to {best_action_sim_state_sequence[-1]['timestep']}")

+6116:         if VALIDATE_ALL_SIMULATED_STATES and not PRUNE_SIM_STATE_SEQUENCE:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_VALIDATE_ALL_SIMULATED_STATES); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6116, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_19) {
  } else {
    __pyx_t_29 = __pyx_t_19;
    goto __pyx_L63_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PRUNE_SIM_STATE_SEQUENCE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 6116, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_2 = (!__pyx_t_19);
  __pyx_t_29 = __pyx_t_2;
  __pyx_L63_bool_binop_done:;
  if (__pyx_t_29) {
/* … */
  }

+6117:             for state in best_action_sim_state_sequence:  # REMOVE_FOR_COMPETITION

    if (likely(PyList_CheckExact(__pyx_v_best_action_sim_state_sequence)) || PyTuple_CheckExact(__pyx_v_best_action_sim_state_sequence)) {
      __pyx_t_1 = __pyx_v_best_action_sim_state_sequence; __Pyx_INCREF(__pyx_t_1);
      __pyx_t_6 = 0;
      __pyx_t_11 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_best_action_sim_state_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6117, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6117, __pyx_L1_error)
    }
    for (;;) {
      if (likely(!__pyx_t_11)) {
        if (likely(PyList_CheckExact(__pyx_t_1))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6117, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_25 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6117, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_25 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6));
          #else
          __pyx_t_25 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6117, __pyx_L1_error)
      } else {
        __pyx_t_25 = __pyx_t_11(__pyx_t_1);
        if (unlikely(!__pyx_t_25)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6117, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_XDECREF_SET(__pyx_v_state, __pyx_t_25);
      __pyx_t_25 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6118:                 self.simulated_gamestate_history[state.timestep] = state  # REMOVE_FOR_COMPETITION

      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6118, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_state, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6118, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      if (unlikely((PyObject_SetItem(__pyx_t_25, __pyx_t_20, __pyx_v_state) < 0))) __PYX_ERR(0, 6118, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6119:         if PRINT_EXPLANATIONS:

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PRINT_EXPLANATIONS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6119, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_29) {
/* … */
  }

+6120:             explanation_messages = best_action_sim.get_explanations()

    __pyx_t_20 = __pyx_v_best_action_sim;
    __Pyx_INCREF(__pyx_t_20);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_20, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_explanations, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6120, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_explanation_messages = __pyx_t_1;
    __pyx_t_1 = 0;

+6121:             for explanation in explanation_messages:

    if (likely(PyList_CheckExact(__pyx_v_explanation_messages)) || PyTuple_CheckExact(__pyx_v_explanation_messages)) {
      __pyx_t_1 = __pyx_v_explanation_messages; __Pyx_INCREF(__pyx_t_1);
      __pyx_t_6 = 0;
      __pyx_t_11 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_explanation_messages); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6121, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6121, __pyx_L1_error)
    }
    for (;;) {
      if (likely(!__pyx_t_11)) {
        if (likely(PyList_CheckExact(__pyx_t_1))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6121, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_20 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6121, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_20 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6));
          #else
          __pyx_t_20 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6121, __pyx_L1_error)
      } else {
        __pyx_t_20 = __pyx_t_11(__pyx_t_1);
        if (unlikely(!__pyx_t_20)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6121, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_XDECREF_SET(__pyx_v_explanation, __pyx_t_20);
      __pyx_t_20 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6122:                 print_explanation(explanation, self.current_timestep)

      __pyx_t_25 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6122, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6122, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_25 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_25);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_25);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_25, __pyx_v_explanation, __pyx_t_21};
        __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6122, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
      }
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6123:             if random.random() < 0.1:

    __pyx_t_20 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6123, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6123, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_21))) {
      __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_21);
      assert(__pyx_t_20);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21);
      __Pyx_INCREF(__pyx_t_20);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_21, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_20, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6123, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_21 = PyObject_RichCompare(__pyx_t_1, __pyx_mstate_global->__pyx_float_0_1, Py_LT); __Pyx_XGOTREF(__pyx_t_21); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6123, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6123, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    if (__pyx_t_29) {
/* … */
    }

 6124:                 # Only periodically print this explanation, as I don't want it to spam the screen too much

+6125:                 print_explanation(f"I currently feel {weighted_average(overall_fitness_record):.0%} safe, considering how long I can stay here without being hit by asteroids or mines, and my proximity to the other ship.", self.current_timestep)

      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6125, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6125, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6125, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_22 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_25); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6125, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_Format(__pyx_t_22, __pyx_mstate_global->__pyx_kp_u_0); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6125, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_I_currently_feel;
      __pyx_t_7[1] = __pyx_t_25;
      __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_safe_considering_how_long_I_can;
      __pyx_t_22 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 17 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25) + 120, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25));
      if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6125, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6125, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_20))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_20);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_20);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_20, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_22, __pyx_t_25};
        __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_20, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6125, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
      }
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

 6126:         # end_state = sim_ship.get_state_sequence()[-1]

 6127:         #assert self.stationary_targetting_sim_index is not None

 6128:         #print(f"Maneuver fitness: {best_action_fitness}, stationary fitness: {self.sims_this_planning_period[self.stationary_targetting_sim_index]['fitness']} stationary fitness breakdown: {self.sims_this_planning_period[self.stationary_targetting_sim_index]['fitness_breakdown']}")

 6129:         # print('state seq:', best_action_sim_state_sequence)

 6130:         # debug_print('Best move seq:', best_move_sequence)

 6131:         # debug_print(f"Best sim index: {self.best_fitness_this_planning_period_index}")

 6132:         # debug_print(f"Choosing action: {self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['action_type']} with fitness {best_action_fitness} {best_action_fitness_breakdown}")

 6133:         # print('all sims this planning period:')

 6134:         # print(self.sims_this_planning_period)

+6135:         if not best_action_sim_state_sequence:

  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_v_best_action_sim_state_sequence); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6135, __pyx_L1_error)
  __pyx_t_2 = (!__pyx_t_29);
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+6136:             raise Exception("Why in the world is this state sequence empty?")

    __pyx_t_20 = NULL;
    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
    __pyx_t_25 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
    __pyx_t_9 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_mstate_global->__pyx_kp_u_Why_in_the_world_is_this_state_s};
      __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_25, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6136, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
    }
    __Pyx_Raise(__pyx_t_21, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    __PYX_ERR(0, 6136, __pyx_L1_error)

+6137:         best_action_sim_last_state = best_action_sim_state_sequence[-1]

  __pyx_t_21 = __Pyx_GetItemInt(__pyx_v_best_action_sim_state_sequence, -1L, long, 1, __Pyx_PyLong_From_long, 0, 1, 0); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6137, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __pyx_v_best_action_sim_last_state = __pyx_t_21;
  __pyx_t_21 = 0;

 6138:         # Prune out the list of asteroids we shot at if the timestep (key) is in the past

+6139:         asteroids_pending_death = best_action_sim.get_asteroids_pending_death()

  __pyx_t_25 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_25);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_25, NULL};
    __pyx_t_21 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_asteroids_pending_death, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6139, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  __pyx_v_asteroids_pending_death = __pyx_t_21;
  __pyx_t_21 = 0;

 6140:         # debug_print(f"Timesteps in asteroids pending death: {[timestep for timestep in asteroids_pending_death.keys()]}")

 6141:         #print(f"Size of asts pending death: {sys.getsizeof()}")

 6142:         #global asteroids_pending_death_total_cull_time

 6143:         #start_time = time.perf_counter()

 6144:         #asteroids_pending_death = {timestep: asteroids for timestep, asteroids in asteroids_pending_death.items() if timestep >= best_action_sim_last_state.timestep}

+6145:         for timestep in range(self.current_timestep, best_action_sim_last_state.timestep):

  __pyx_t_25 = NULL;
  __Pyx_INCREF(__pyx_builtin_range);
  __pyx_t_20 = __pyx_builtin_range; 
  __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_best_action_sim_last_state, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = 1;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_25, __pyx_t_22, __pyx_t_1};
    __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_20, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6145, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  if (likely(PyList_CheckExact(__pyx_t_21)) || PyTuple_CheckExact(__pyx_t_21)) {
    __pyx_t_20 = __pyx_t_21; __Pyx_INCREF(__pyx_t_20);
    __pyx_t_6 = 0;
    __pyx_t_11 = NULL;
  } else {
    __pyx_t_6 = -1; __pyx_t_20 = PyObject_GetIter(__pyx_t_21); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6145, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
    __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_20); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6145, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  for (;;) {
    if (likely(!__pyx_t_11)) {
      if (likely(PyList_CheckExact(__pyx_t_20))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_20);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6145, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        __pyx_t_21 = __Pyx_PyList_GetItemRef(__pyx_t_20, __pyx_t_6);
        ++__pyx_t_6;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_20);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6145, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_21 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_20, __pyx_t_6));
        #else
        __pyx_t_21 = __Pyx_PySequence_ITEM(__pyx_t_20, __pyx_t_6);
        #endif
        ++__pyx_t_6;
      }
      if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6145, __pyx_L1_error)
    } else {
      __pyx_t_21 = __pyx_t_11(__pyx_t_20);
      if (unlikely(!__pyx_t_21)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6145, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_21);
    __Pyx_XDECREF_SET(__pyx_v_timestep, __pyx_t_21);
    __pyx_t_21 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6146:             if timestep in asteroids_pending_death:

    __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_timestep, __pyx_v_asteroids_pending_death, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6146, __pyx_L1_error)
    if (__pyx_t_2) {
/* … */
    }

+6147:                 del asteroids_pending_death[timestep]

      if (unlikely((PyObject_DelItem(__pyx_v_asteroids_pending_death, __pyx_v_timestep) < 0))) __PYX_ERR(0, 6147, __pyx_L1_error)

 6148:         #asteroids_pending_death_total_cull_time += time.perf_counter() - start_time

+6149:         forecasted_asteroid_splits = best_action_sim.get_forecasted_asteroid_splits()

  __pyx_t_21 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_21);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_21, NULL};
    __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_forecasted_asteroid_splits, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
    if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6149, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
  }
  __pyx_v_forecasted_asteroid_splits = __pyx_t_20;
  __pyx_t_20 = 0;

+6150:         next_base_game_state = best_action_sim.get_game_state()

  __pyx_t_21 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_21);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_21, NULL};
    __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_game_state, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
    if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6150, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
  }
  __pyx_v_next_base_game_state = __pyx_t_20;
  __pyx_t_20 = 0;

 6151:         #print(f"Ast pending death keys: {asteroids_pending_death.keys()}")

 6152:         # Made this change, because if we're waiting out mines, that'll mess up the game state. But the state sequence still has the last actual game state, so we'll use that!

 6153:         # next_base_game_state = best_action_sim_last_state['game_state']

 6154:         # print(f'\nNext base game state for timestep {best_action_sim_last_state["timestep"]}:')

+6155:         self.set_of_base_gamestate_timesteps.add(best_action_sim_last_state.timestep)

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_of_base_gamestate_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_21 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_21);
  __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_best_action_sim_last_state, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_21, __pyx_t_22};
    __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6155, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
  }
  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6156:         new_ship_state = best_action_sim.get_ship_state()

  __pyx_t_1 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
    __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_ship_state, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6156, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
  }
  __pyx_v_new_ship_state = __pyx_t_20;
  __pyx_t_20 = 0;

+6157:         new_fire_next_timestep_flag = best_action_sim.get_fire_next_timestep_flag()

  __pyx_t_1 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
    __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fire_next_timestep_flag, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
  }
  __pyx_v_new_fire_next_timestep_flag = __pyx_t_20;
  __pyx_t_20 = 0;

 6158:         # print(f"Firing next ts status is: {new_fire_next_timestep_flag}")

+6159:         if new_ship_state.is_respawning and new_fire_next_timestep_flag and new_ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for:

  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6159, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6159, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
  if (__pyx_t_29) {
  } else {
    __pyx_t_2 = __pyx_t_29;
    goto __pyx_L79_bool_binop_done;
  }
  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_v_new_fire_next_timestep_flag); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6159, __pyx_L1_error)
  if (__pyx_t_29) {
  } else {
    __pyx_t_2 = __pyx_t_29;
    goto __pyx_L79_bool_binop_done;
  }
  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6159, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6159, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_29 = (__Pyx_PySequence_ContainsTF(__pyx_t_20, __pyx_t_1, Py_NE)); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6159, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_2 = __pyx_t_29;
  __pyx_L79_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

 6160:             # print(f"Forcing off the fire next timestep, because we just took damage")

+6161:             new_fire_next_timestep_flag = False

    __Pyx_INCREF(Py_False);
    __Pyx_DECREF_SET(__pyx_v_new_fire_next_timestep_flag, Py_False);

+6162:         if ENABLE_SANITY_CHECKS and new_ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for and new_ship_state.is_respawning:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6162, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_29) {
  } else {
    __pyx_t_2 = __pyx_t_29;
    goto __pyx_L83_bool_binop_done;
  }
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __pyx_t_29 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_20, Py_NE)); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6162, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
  if (__pyx_t_29) {
  } else {
    __pyx_t_2 = __pyx_t_29;
    goto __pyx_L83_bool_binop_done;
  }
  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_20);
  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6162, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
  __pyx_t_2 = __pyx_t_29;
  __pyx_L83_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

 6163:             # If our ship is hurt in our next next action and I haven't done a respawn maneuver yet (in this situation, the next next action is a respawn maneuver)  # REMOVE_FOR_COMPETITION

 6164:             # Then I assert that our next action is not a respawning action, AND we're not firing at the start of the next next action  # REMOVE_FOR_COMPETITION

+6165:             if (self.game_state_to_base_planning['respawning'] or new_fire_next_timestep_flag):  # REMOVE_FOR_COMPETITION

    __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6165, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_20);
    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6165, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
    __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6165, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (!__pyx_t_29) {
    } else {
      __pyx_t_2 = __pyx_t_29;
      goto __pyx_L87_bool_binop_done;
    }
    __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_v_new_fire_next_timestep_flag); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6165, __pyx_L1_error)
    __pyx_t_2 = __pyx_t_29;
    __pyx_L87_bool_binop_done:;
    if (__pyx_t_2) {
/* … */
    }

+6166:                 print(f"We haven't done a respawn maneuver for having {new_ship_state.lives_remaining} lives left")  # REMOVE_FOR_COMPETITION

      __pyx_t_20 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_22 = __pyx_builtin_print; 
      __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6166, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_25 = __Pyx_PyObject_FormatSimple(__pyx_t_21, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6166, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_We_haven_t_done_a_respawn_maneuv;
      __pyx_t_7[1] = __pyx_t_25;
      __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_lives_left_2;
      __pyx_t_21 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 46 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25) + 11, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25));
      if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6166, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_9 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_t_21};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_22, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6166, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6167:                 print(f"self.game_state_to_base_planning['respawning']: {self.game_state_to_base_planning['respawning']}, new_fire_next_timestep_flag: {new_fire_next_timestep_flag}, {best_action_sim.get_respawn_timer()=}")  # REMOVE_FOR_COMPETITION

      __pyx_t_22 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_21 = __pyx_builtin_print; 
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_20 = __Pyx_PyObject_FormatSimple(__pyx_t_25, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_FormatSimple(__pyx_v_new_fire_next_timestep_flag, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_best_action_sim, __pyx_mstate_global->__pyx_n_u_get_respawn_timer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_5), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_31[0] = __pyx_mstate_global->__pyx_kp_u_self_game_state_to_base_planning;
      __pyx_t_31[1] = __pyx_t_20;
      __pyx_t_31[2] = __pyx_mstate_global->__pyx_kp_u_new_fire_next_timestep_flag;
      __pyx_t_31[3] = __pyx_t_25;
      __pyx_t_31[4] = __pyx_mstate_global->__pyx_kp_u_best_action_sim_get_respawn_tim;
      __pyx_t_31[5] = __pyx_t_3;
      __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_31, 6, 48 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_20) + 31 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25) + 38 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_20) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3));
      if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6167, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_9 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_22, __pyx_t_5};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6167, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6168:             # assert not (self.game_state_to_base_planning['respawning'] or new_fire_next_timestep_flag)  # REMOVE_FOR_COMPETITION

 6169:         # print(f"{new_ship_state.lives_remaining=}, {str(self.lives_remaining_that_we_did_respawn_maneuver_for)=}, {new_ship_state.is_respawning=}")

 6170:         # debug_print(f"Deciding next action on ts {self.current_timestep}! The new planning ship speed is {new_ship_state.speed} and the move sequence we're executing is REDACTED best_move_sequence, type is {self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['action_type']}")

+6171:         self.game_state_to_base_planning = {

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning, __pyx_t_1) < 0) __PYX_ERR(0, 6171, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6172:             'timestep': best_action_sim_last_state.timestep,

  __pyx_t_1 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_best_action_sim_last_state, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_21) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6173:             'respawning': new_ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for and new_ship_state.is_respawning,

  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_t_22, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6173, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_22 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_22);
    __pyx_t_21 = __pyx_t_22;
    __pyx_t_22 = 0;
    goto __pyx_L89_bool_binop_done;
  }
  __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_INCREF(__pyx_t_22);
  __pyx_t_21 = __pyx_t_22;
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  __pyx_L89_bool_binop_done:;
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_respawning, __pyx_t_21) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6174:             'ship_state': new_ship_state,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_v_new_ship_state) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)

+6175:             'game_state': next_base_game_state,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_v_next_base_game_state) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)

+6176:             'ship_respawn_timer': best_action_sim.get_respawn_timer(),

  __pyx_t_22 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_22);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_22, NULL};
    __pyx_t_21 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_respawn_timer, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6176, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_t_21) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6177:             'asteroids_pending_death': asteroids_pending_death,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_v_asteroids_pending_death) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)

+6178:             'forecasted_asteroid_splits': forecasted_asteroid_splits,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_v_forecasted_asteroid_splits) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)

+6179:             'last_timestep_fired': best_action_sim.get_last_timestep_fired(),

  __pyx_t_22 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_22);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_22, NULL};
    __pyx_t_21 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_last_timestep_fired, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6179, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_21) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6180:             'last_timestep_mined': best_action_sim.get_last_timestep_mined(),

  __pyx_t_22 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_22);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_22, NULL};
    __pyx_t_21 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_last_timestep_mined, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6180, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_21) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6181:             'mine_positions_placed': best_action_sim.get_mine_positions_placed(),

  __pyx_t_22 = __pyx_v_best_action_sim;
  __Pyx_INCREF(__pyx_t_22);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_22, NULL};
    __pyx_t_21 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_mine_positions_placed, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6181, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_21) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6182:             'fire_next_timestep_flag': new_fire_next_timestep_flag,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, __pyx_v_new_fire_next_timestep_flag) < 0) __PYX_ERR(0, 6172, __pyx_L1_error)

 6183:         }

 6184:         #print('New base gamestate:')

 6185:         #print(next_base_game_state)

 6186:         #print('New base shipstate:')

 6187:         #print(new_ship_state)

+6188:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6188, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6188, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+6189:             if not (bool(self.game_state_to_base_planning['ship_respawn_timer']) == self.game_state_to_base_planning['ship_state'].is_respawning):  # REMOVE_FOR_COMPETITION

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    __pyx_t_21 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_22 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_22);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    __pyx_t_22 = PyObject_RichCompare(__pyx_t_21, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_22); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6189, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    __pyx_t_29 = (!__pyx_t_2);
    if (__pyx_t_29) {
/* … */
    }

+6190:                 print(f"self.game_state_to_base_planning['ship_respawn_timer']: {self.game_state_to_base_planning['ship_respawn_timer']}, self.game_state_to_base_planning['ship_state'].is_respawning: {self.game_state_to_base_planning['ship_state'].is_respawning}")  # REMOVE_FOR_COMPETITION

      __pyx_t_1 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_21 = __pyx_builtin_print; 
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_25 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_26[0] = __pyx_mstate_global->__pyx_kp_u_self_game_state_to_base_planning_2;
      __pyx_t_26[1] = __pyx_t_5;
      __pyx_t_26[2] = __pyx_mstate_global->__pyx_kp_u_self_game_state_to_base_plannin;
      __pyx_t_26[3] = __pyx_t_25;
      __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_26, 4, 56 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 64 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_25));
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6190, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_9 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3};
        __pyx_t_22 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6190, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
      }
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;

+6191:             assert bool(self.game_state_to_base_planning['ship_respawn_timer']) == self.game_state_to_base_planning['ship_state'].is_respawning  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __pyx_t_21 = __Pyx_PyBool_FromLong((!(!__pyx_t_29))); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_21, __pyx_t_22, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6191, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_29)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 6191, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 6191, __pyx_L1_error)
    #endif

+6192:         if self.game_state_to_base_planning['respawning']:

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_22 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6192, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (__pyx_t_29) {
/* … */
  }

 6193:             # print(f"Adding to lives remaining that we did respawn for, in decide next action: {new_ship_state.lives_remaining}")

+6194:             self.lives_remaining_that_we_did_respawn_maneuver_for.add(new_ship_state.lives_remaining)

    __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6194, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
    __pyx_t_3 = __pyx_t_21;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6194, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_1};
      __pyx_t_22 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6194, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
    }
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;

 6195:         # debug_print(f"The next base state's respawning state is {self.game_state_to_base_planning['respawning']}")

 6196:         # debug_print("The new ship state is", new_ship_state)

 6197:         # debug_print(f"The fire next timestep flag is: {new_fire_next_timestep_flag}")

 6198:         # debug_print(f"\nNext base state ts: {self.game_state_to_base_planning['timestep']}, respawn maneuver: {self.game_state_to_base_planning['respawning']}, respawn timer: {self.game_state_to_base_planning['ship_respawn_timer']}, ship state: {new_ship_state}")

+6199:         self.base_gamestates[best_action_sim_last_state.timestep] = self.game_state_to_base_planning

  __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestates); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_best_action_sim_last_state, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (unlikely((PyObject_SetItem(__pyx_t_21, __pyx_t_1, __pyx_t_22) < 0))) __PYX_ERR(0, 6199, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;

 6200:         state_dump_dict = {

+6201:             'timestep': self.game_state_to_base_planning['timestep'],

  __pyx_t_22 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_21) < 0) __PYX_ERR(0, 6201, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6202:             'ship_state': self.game_state_to_base_planning['ship_state'],

  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_1) < 0) __PYX_ERR(0, 6201, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6203:             'asteroids': self.game_state_to_base_planning['game_state'].asteroids,

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_1) < 0) __PYX_ERR(0, 6201, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6204:             'bullets': self.game_state_to_base_planning['game_state'].bullets,

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_21 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_1) < 0) __PYX_ERR(0, 6201, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_state_dump_dict = ((PyObject*)__pyx_t_22);
  __pyx_t_22 = 0;

 6205:         }

+6206:         if KEY_STATE_DUMP:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_KEY_STATE_DUMP); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (__pyx_t_29) {
/* … */
  }

+6207:             append_dict_to_file(state_dump_dict, 'Key Simulation State Dump.txt')  # REMOVE_FOR_COMPETITION

    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_append_dict_to_file); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_21))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_21);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_21, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_state_dump_dict, __pyx_mstate_global->__pyx_kp_u_Key_Simulation_State_Dump_txt};
      __pyx_t_22 = __Pyx_PyObject_FastCall(__pyx_t_21, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
      if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6207, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
    }
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;

 6208: 

+6209:         if SIMULATION_STATE_DUMP and best_action_sim_last_state is not None:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_SIMULATION_STATE_DUMP); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6209, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6209, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_29 = __pyx_t_2;
    goto __pyx_L96_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_best_action_sim_last_state != Py_None);
  __pyx_t_29 = __pyx_t_2;
  __pyx_L96_bool_binop_done:;
  if (__pyx_t_29) {
/* … */
  }

+6210:             for sim_state in best_action_sim_state_sequence:  # REMOVE_FOR_COMPETITION

    if (likely(PyList_CheckExact(__pyx_v_best_action_sim_state_sequence)) || PyTuple_CheckExact(__pyx_v_best_action_sim_state_sequence)) {
      __pyx_t_22 = __pyx_v_best_action_sim_state_sequence; __Pyx_INCREF(__pyx_t_22);
      __pyx_t_6 = 0;
      __pyx_t_11 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_22 = PyObject_GetIter(__pyx_v_best_action_sim_state_sequence); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6210, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_22); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6210, __pyx_L1_error)
    }
    for (;;) {
      if (likely(!__pyx_t_11)) {
        if (likely(PyList_CheckExact(__pyx_t_22))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_22);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6210, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_21 = __Pyx_PyList_GetItemRef(__pyx_t_22, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_22);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6210, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_21 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_22, __pyx_t_6));
          #else
          __pyx_t_21 = __Pyx_PySequence_ITEM(__pyx_t_22, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6210, __pyx_L1_error)
      } else {
        __pyx_t_21 = __pyx_t_11(__pyx_t_22);
        if (unlikely(!__pyx_t_21)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6210, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_21);
      __Pyx_XDECREF_SET(__pyx_v_sim_state, __pyx_t_21);
      __pyx_t_21 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;

+6211:                 append_dict_to_file(cast(dict[Any, Any], sim_state), 'Simulation State Dump.txt')  # REMOVE_FOR_COMPETITION

      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_append_dict_to_file); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6211, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6211, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_GetModuleGlobalName(__pyx_t_24, __pyx_mstate_global->__pyx_n_u_Any); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 6211, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
      __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_Any); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6211, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 6211, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_GIVEREF(__pyx_t_24);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_24) != (0)) __PYX_ERR(0, 6211, __pyx_L1_error);
      __Pyx_GIVEREF(__pyx_t_23);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_23) != (0)) __PYX_ERR(0, 6211, __pyx_L1_error);
      __pyx_t_24 = 0;
      __pyx_t_23 = 0;
      __pyx_t_23 = __Pyx_PyObject_GetItem(((PyObject *)(&PyDict_Type)), __pyx_t_12); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6211, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_20))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_20);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_20);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_20, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_23, __pyx_v_sim_state};
        __pyx_t_25 = __Pyx_PyObject_FastCall(__pyx_t_20, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6211, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_25);
      }
      __pyx_t_9 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_9 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_25, __pyx_mstate_global->__pyx_kp_u_Simulation_State_Dump_txt};
        __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6211, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_21);
      }
      __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6212:         if self.game_state_plotter is not None and best_action_sim_state_sequence is not None and GAMESTATE_PLOTTING and MANEUVER_SIM_PLOTTING and (START_GAMESTATE_PLOTTING_AT_SECOND is None or START_GAMESTATE_PLOTTING_AT_SECOND*FPS <= float(self.current_timestep)):  # REMOVE_FOR_COMPETITION

  __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_2 = (__pyx_t_22 != Py_None);
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_29 = __pyx_t_2;
    goto __pyx_L102_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_best_action_sim_state_sequence != Py_None);
  if (__pyx_t_2) {
  } else {
    __pyx_t_29 = __pyx_t_2;
    goto __pyx_L102_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_GAMESTATE_PLOTTING); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_29 = __pyx_t_2;
    goto __pyx_L102_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_MANEUVER_SIM_PLOTTING); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_29 = __pyx_t_2;
    goto __pyx_L102_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __pyx_t_2 = (__pyx_t_22 == Py_None);
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  if (!__pyx_t_2) {
  } else {
    __pyx_t_29 = __pyx_t_2;
    goto __pyx_L102_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __pyx_t_3 = PyNumber_Multiply(__pyx_t_22, __pyx_t_21); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __pyx_t_22 = __Pyx_PyNumber_Float(__pyx_t_21); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_22);
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  __pyx_t_21 = PyObject_RichCompare(__pyx_t_3, __pyx_t_22, Py_LE); __Pyx_XGOTREF(__pyx_t_21); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_21); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6212, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  __pyx_t_29 = __pyx_t_2;
  __pyx_L102_bool_binop_done:;
  if (__pyx_t_29) {
/* … */
  }

+6213:             for sim_state in best_action_sim_state_sequence:  # REMOVE_FOR_COMPETITION

    if (likely(PyList_CheckExact(__pyx_v_best_action_sim_state_sequence)) || PyTuple_CheckExact(__pyx_v_best_action_sim_state_sequence)) {
      __pyx_t_21 = __pyx_v_best_action_sim_state_sequence; __Pyx_INCREF(__pyx_t_21);
      __pyx_t_6 = 0;
      __pyx_t_11 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_21 = PyObject_GetIter(__pyx_v_best_action_sim_state_sequence); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6213, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_21);
      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_21); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6213, __pyx_L1_error)
    }
    for (;;) {
      if (likely(!__pyx_t_11)) {
        if (likely(PyList_CheckExact(__pyx_t_21))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_21);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6213, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          __pyx_t_22 = __Pyx_PyList_GetItemRef(__pyx_t_21, __pyx_t_6);
          ++__pyx_t_6;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_21);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6213, __pyx_L1_error)
            #endif
            if (__pyx_t_6 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_22 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_21, __pyx_t_6));
          #else
          __pyx_t_22 = __Pyx_PySequence_ITEM(__pyx_t_21, __pyx_t_6);
          #endif
          ++__pyx_t_6;
        }
        if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6213, __pyx_L1_error)
      } else {
        __pyx_t_22 = __pyx_t_11(__pyx_t_21);
        if (unlikely(!__pyx_t_22)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6213, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_XDECREF_SET(__pyx_v_sim_state, __pyx_t_22);
      __pyx_t_22 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6214:                 assert sim_state is not None  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_29 = (__pyx_v_sim_state != Py_None);
        if (unlikely(!__pyx_t_29)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6214, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6214, __pyx_L1_error)
      #endif

+6215:                 assert sim_state.asteroids_pending_death is not None  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6215, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __pyx_t_29 = (__pyx_t_22 != Py_None);
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        if (unlikely(!__pyx_t_29)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6215, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6215, __pyx_L1_error)
      #endif

+6216:                 assert sim_state.game_state is not None  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6216, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
        __pyx_t_29 = (__pyx_t_22 != Py_None);
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        if (unlikely(!__pyx_t_29)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6216, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6216, __pyx_L1_error)
      #endif

+6217:                 flattened_asteroids_pending_death = [ast for ast_list in sim_state.asteroids_pending_death.values() for ast in ast_list]  # REMOVE_FOR_COMPETITION

      { /* enter inner scope */
        __pyx_t_22 = PyList_New(0); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6217, __pyx_L112_error)
        __Pyx_GOTREF(__pyx_t_22);
        __pyx_t_15 = 0;
        __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6217, __pyx_L112_error)
        __Pyx_GOTREF(__pyx_t_25);
        if (unlikely(__pyx_t_25 == Py_None)) {
          PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
          __PYX_ERR(0, 6217, __pyx_L112_error)
        }
        __pyx_t_1 = __Pyx_dict_iterator(__pyx_t_25, 0, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_18), (&__pyx_t_32)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6217, __pyx_L112_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_XDECREF(__pyx_t_3);
        __pyx_t_3 = __pyx_t_1;
        __pyx_t_1 = 0;
        while (1) {
          __pyx_t_33 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_18, &__pyx_t_15, NULL, &__pyx_t_1, NULL, __pyx_t_32);
          if (unlikely(__pyx_t_33 == 0)) break;
          if (unlikely(__pyx_t_33 == -1)) __PYX_ERR(0, 6217, __pyx_L112_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_XDECREF_SET(__pyx_9genexpr54__pyx_v_ast_list, __pyx_t_1);
          __pyx_t_1 = 0;
          if (likely(PyList_CheckExact(__pyx_9genexpr54__pyx_v_ast_list)) || PyTuple_CheckExact(__pyx_9genexpr54__pyx_v_ast_list)) {
            __pyx_t_1 = __pyx_9genexpr54__pyx_v_ast_list; __Pyx_INCREF(__pyx_t_1);
            __pyx_t_34 = 0;
            __pyx_t_16 = NULL;
          } else {
            __pyx_t_34 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_9genexpr54__pyx_v_ast_list); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6217, __pyx_L112_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6217, __pyx_L112_error)
          }
          for (;;) {
            if (likely(!__pyx_t_16)) {
              if (likely(PyList_CheckExact(__pyx_t_1))) {
                {
                  Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
                  #if !CYTHON_ASSUME_SAFE_SIZE
                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6217, __pyx_L112_error)
                  #endif
                  if (__pyx_t_34 >= __pyx_temp) break;
                }
                __pyx_t_25 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_34);
                ++__pyx_t_34;
              } else {
                {
                  Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
                  #if !CYTHON_ASSUME_SAFE_SIZE
                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6217, __pyx_L112_error)
                  #endif
                  if (__pyx_t_34 >= __pyx_temp) break;
                }
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                __pyx_t_25 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_34));
                #else
                __pyx_t_25 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_34);
                #endif
                ++__pyx_t_34;
              }
              if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6217, __pyx_L112_error)
            } else {
              __pyx_t_25 = __pyx_t_16(__pyx_t_1);
              if (unlikely(!__pyx_t_25)) {
                PyObject* exc_type = PyErr_Occurred();
                if (exc_type) {
                  if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6217, __pyx_L112_error)
                  PyErr_Clear();
                }
                break;
              }
            }
            __Pyx_GOTREF(__pyx_t_25);
            __Pyx_XDECREF_SET(__pyx_9genexpr54__pyx_v_ast, __pyx_t_25);
            __pyx_t_25 = 0;
            if (unlikely(__Pyx_ListComp_Append(__pyx_t_22, (PyObject*)__pyx_9genexpr54__pyx_v_ast))) __PYX_ERR(0, 6217, __pyx_L112_error)
          }
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        }
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_9genexpr54__pyx_v_ast); __pyx_9genexpr54__pyx_v_ast = 0;
        __Pyx_XDECREF(__pyx_9genexpr54__pyx_v_ast_list); __pyx_9genexpr54__pyx_v_ast_list = 0;
        goto __pyx_L118_exit_scope;
        __pyx_L112_error:;
        __Pyx_XDECREF(__pyx_9genexpr54__pyx_v_ast); __pyx_9genexpr54__pyx_v_ast = 0;
        __Pyx_XDECREF(__pyx_9genexpr54__pyx_v_ast_list); __pyx_9genexpr54__pyx_v_ast_list = 0;
        goto __pyx_L1_error;
        __pyx_L118_exit_scope:;
      } /* exit inner scope */
      __Pyx_XDECREF_SET(__pyx_v_flattened_asteroids_pending_death, ((PyObject*)__pyx_t_22));
      __pyx_t_22 = 0;

+6218:                 self.game_state_plotter.update_plot(sim_state.game_state.asteroids, sim_state.ship_state, sim_state.game_state.bullets, [], [], flattened_asteroids_pending_death, sim_state.forecasted_asteroid_splits, sim_state.game_state.mines, True, 0.1, f"MANEUVER SIMULATION PREVIEW TIMESTEP {self.current_timestep}")  # REMOVE_FOR_COMPETITION

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = __pyx_t_1;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
      __pyx_t_25 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_25);
      __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __pyx_t_23 = PyList_New(0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __pyx_t_12 = PyList_New(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_24);
      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_sim_state, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_t_14, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_14 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_MANEUVER_SIMULATION_PREVIEW_TIME, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6218, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[12] = {__pyx_t_3, __pyx_t_20, __pyx_t_25, __pyx_t_5, __pyx_t_23, __pyx_t_12, __pyx_v_flattened_asteroids_pending_death, __pyx_t_24, __pyx_t_4, Py_True, __pyx_mstate_global->__pyx_float_0_1, __pyx_t_14};
        __pyx_t_22 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update_plot, __pyx_callargs+__pyx_t_9, (12-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6218, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_22);
      }
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;

 6219:         # print(f"Best move sequence:", best_move_sequence)

+6220:         for move in best_move_sequence:

  if (likely(PyList_CheckExact(__pyx_v_best_move_sequence)) || PyTuple_CheckExact(__pyx_v_best_move_sequence)) {
    __pyx_t_21 = __pyx_v_best_move_sequence; __Pyx_INCREF(__pyx_t_21);
    __pyx_t_6 = 0;
    __pyx_t_11 = NULL;
  } else {
    __pyx_t_6 = -1; __pyx_t_21 = PyObject_GetIter(__pyx_v_best_move_sequence); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6220, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
    __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_21); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6220, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_11)) {
      if (likely(PyList_CheckExact(__pyx_t_21))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_21);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6220, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        __pyx_t_22 = __Pyx_PyList_GetItemRef(__pyx_t_21, __pyx_t_6);
        ++__pyx_t_6;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_21);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6220, __pyx_L1_error)
          #endif
          if (__pyx_t_6 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_22 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_21, __pyx_t_6));
        #else
        __pyx_t_22 = __Pyx_PySequence_ITEM(__pyx_t_21, __pyx_t_6);
        #endif
        ++__pyx_t_6;
      }
      if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6220, __pyx_L1_error)
    } else {
      __pyx_t_22 = __pyx_t_11(__pyx_t_21);
      if (unlikely(!__pyx_t_22)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6220, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_22);
    __Pyx_XDECREF_SET(__pyx_v_move, __pyx_t_22);
    __pyx_t_22 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6221:             if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6221, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_22);
    __pyx_t_29 = __Pyx_PyObject_IsTrue(__pyx_t_22); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6221, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
    if (__pyx_t_29) {
/* … */
    }

+6222:                 if not move.timestep not in self.actioned_timesteps:  # REMOVE_FOR_COMPETITION

      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6222, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actioned_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6222, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_29 = (__Pyx_PySequence_ContainsTF(__pyx_t_22, __pyx_t_1, Py_EQ)); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6222, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__pyx_t_29) {
/* … */
      }

+6223:                     print("DUPLICATE TIMESTEPS")  # REMOVE_FOR_COMPETITION

        __pyx_t_22 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_14 = __pyx_builtin_print; 
        __pyx_t_9 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_22, __pyx_mstate_global->__pyx_kp_u_DUPLICATE_TIMESTEPS};
          __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6223, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6224:                     print('actioned timesteps:', self.actioned_timesteps)  # REMOVE_FOR_COMPETITION

        __pyx_t_14 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_22 = __pyx_builtin_print; 
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actioned_timesteps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6224, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_9 = 1;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_14, __pyx_mstate_global->__pyx_kp_u_actioned_timesteps_2, __pyx_t_4};
          __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_22, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6224, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6225:                     print('best move sequence:', best_move_sequence)  # REMOVE_FOR_COMPETITION

        __pyx_t_22 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_4 = __pyx_builtin_print; 
        __pyx_t_9 = 1;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_22, __pyx_mstate_global->__pyx_kp_u_best_move_sequence, __pyx_v_best_move_sequence};
          __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6225, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6226:                 assert move.timestep not in self.actioned_timesteps, "DUPLICATE TIMESTEPS IN ENQUEUED MOVES"  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6226, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actioned_timesteps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6226, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_29 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_4, Py_NE)); if (unlikely((__pyx_t_29 < 0))) __PYX_ERR(0, 6226, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_29)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_mstate_global->__pyx_kp_u_DUPLICATE_TIMESTEPS_IN_ENQUEUED, 0, 0);
          __PYX_ERR(0, 6226, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6226, __pyx_L1_error)
      #endif

+6227:                 self.actioned_timesteps.add(move.timestep)  # REMOVE_FOR_COMPETITION

      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actioned_timesteps); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6227, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_1 = __pyx_t_22;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6227, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_14};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6227, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6228:             self.enqueue_action(move.timestep, move.thrust, move.turn_rate, move.fire, move.drop_mine)

    __pyx_t_22 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_22);
    __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_thrust); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_turn_rate); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 6228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_24);
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_fire); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 6228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_move, __pyx_mstate_global->__pyx_n_u_drop_mine); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[6] = {__pyx_t_22, __pyx_t_14, __pyx_t_1, __pyx_t_24, __pyx_t_12, __pyx_t_23};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_enqueue_action, __pyx_callargs+__pyx_t_9, (6-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6228, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6229:         self.sims_this_planning_period.clear()

  __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_23);
  __pyx_t_4 = __pyx_t_23;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_21 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6229, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6230:         self.best_fitness_this_planning_period = -INFINITY

  __pyx_t_21 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_t_21) < 0) __PYX_ERR(0, 6230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6231:         self.best_fitness_this_planning_period_index = INT_NEG_INF

  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_21) < 0) __PYX_ERR(0, 6231, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6232:         self.second_best_fitness_this_planning_period = -INFINITY

  __pyx_t_21 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_21) < 0) __PYX_ERR(0, 6232, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6233:         self.second_best_fitness_this_planning_period_index = INT_NEG_INF

  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_21) < 0) __PYX_ERR(0, 6233, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6234:         self.stationary_targetting_sim_index = INT_NEG_INF

  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index, __pyx_t_21) < 0) __PYX_ERR(0, 6234, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6235:         self.base_gamestate_analysis = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestate_analysis, Py_None) < 0) __PYX_ERR(0, 6235, __pyx_L1_error)

 6236:         global unwrap_cache

+6237:         unwrap_cache.clear()

  __pyx_t_23 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_unwrap_cache); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_clear); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 6237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_9 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_12))) {
    __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_12);
    assert(__pyx_t_23);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
    __Pyx_INCREF(__pyx_t_23);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
    __pyx_t_9 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_23, NULL};
    __pyx_t_21 = __Pyx_PyObject_FastCall(__pyx_t_12, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 6237, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_21);
  }
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

+6238:         return True

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_True);
  __pyx_r = Py_True;
  goto __pyx_L0;

 6239: 

+6240:     def plan_action(self, other_ships_exist: bool, base_state_is_exact: bool, iterations_boost: bool = False, plan_stationary: bool = False) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_25plan_action(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_25plan_action = {"plan_action", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_25plan_action, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_25plan_action(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_other_ships_exist = 0;
  PyObject *__pyx_v_base_state_is_exact = 0;
  CYTHON_UNUSED PyObject *__pyx_v_iterations_boost = 0;
  PyObject *__pyx_v_plan_stationary = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("plan_action (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_other_ships_exist,&__pyx_mstate_global->__pyx_n_u_base_state_is_exact,&__pyx_mstate_global->__pyx_n_u_iterations_boost,&__pyx_mstate_global->__pyx_n_u_plan_stationary,0};
  PyObject* values[5] = {0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 6240, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 6240, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 6240, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 6240, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 6240, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 6240, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "plan_action", 0) < 0) __PYX_ERR(0, 6240, __pyx_L3_error)
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("plan_action", 0, 3, 5, i); __PYX_ERR(0, 6240, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 6240, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 6240, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 6240, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 6240, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 6240, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
      if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False)));
    }
    __pyx_v_self = values[0];
    __pyx_v_other_ships_exist = values[1];
    __pyx_v_base_state_is_exact = values[2];
    __pyx_v_iterations_boost = values[3];
    __pyx_v_plan_stationary = values[4];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("plan_action", 0, 3, 5, __pyx_nargs); __PYX_ERR(0, 6240, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.plan_action", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_24plan_action(__pyx_self, __pyx_v_self, __pyx_v_other_ships_exist, __pyx_v_base_state_is_exact, __pyx_v_iterations_boost, __pyx_v_plan_stationary);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_14neo_controller_13NeoController_11plan_action_2generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
static PyObject *__pyx_pf_14neo_controller_13NeoController_24plan_action(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other_ships_exist, PyObject *__pyx_v_base_state_is_exact, CYTHON_UNUSED PyObject *__pyx_v_iterations_boost, PyObject *__pyx_v_plan_stationary) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_14_plan_action *__pyx_cur_scope;
  PyObject *__pyx_v_state_type = NULL;
  PyObject *__pyx_v_MAX_CRUISE_SECONDS = NULL;
  PyObject *__pyx_v_search_iterations_count = NULL;
  Py_ssize_t __pyx_v_num_sims_this_planning_period;
  PyObject *__pyx_v_random_ship_heading_angle = NULL;
  PyObject *__pyx_v_ship_accel_turn_rate = NULL;
  PyObject *__pyx_v_ship_cruise_speed = NULL;
  PyObject *__pyx_v_ship_cruise_turn_rate = NULL;
  PyObject *__pyx_v_ship_cruise_timesteps = NULL;
  PyObject *__pyx_v_maneuver_sim = NULL;
  PyObject *__pyx_v_maneuver_fitness = NULL;
  PyObject *__pyx_v_ship_is_stationary = NULL;
  PyObject *__pyx_v_stationary_targetting_sim = NULL;
  PyObject *__pyx_v_best_stationary_targetting_fitness = NULL;
  int __pyx_v_heuristic_maneuver;
  PyObject *__pyx_v_imminent_asteroid_speed = NULL;
  PyObject *__pyx_v_imminent_asteroid_relative_heading = NULL;
  PyObject *__pyx_v_largest_gap_relative_heading = NULL;
  PyObject *__pyx_v_nearby_asteroid_average_speed = NULL;
  PyObject *__pyx_v_nearby_asteroid_count = NULL;
  PyObject *__pyx_v_average_directional_speed = NULL;
  PyObject *__pyx_v_total_asteroids_count = NULL;
  PyObject *__pyx_v_current_asteroids_count = NULL;
  PyObject *__pyx_v_ship_cruise_speed_mode = NULL;
  PyObject *__pyx_v_ship_cruise_timesteps_mode = NULL;
  double __pyx_v_max_pre_maneuver_turn_timesteps;
  PyObject *__pyx_v_ship_cruise_timesteps_float = NULL;
  PyObject *__pyx_v_thrust_direction = NULL;
  PyObject *__pyx_v_preview_move_sequence = NULL;
  PyObject *__pyx_v_maneuver_fitness_breakdown = NULL;
  PyObject *__pyx_gb_14neo_controller_13NeoController_11plan_action_2generator6 = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_14_plan_action *)__pyx_tp_new_14neo_controller___pyx_scope_struct_14_plan_action(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_14_plan_action, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_14_plan_action *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 6240, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_self = __pyx_v_self;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_AddTraceback("neo_controller.NeoController.plan_action", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_state_type);
  __Pyx_XDECREF(__pyx_v_MAX_CRUISE_SECONDS);
  __Pyx_XDECREF(__pyx_v_search_iterations_count);
  __Pyx_XDECREF(__pyx_v_random_ship_heading_angle);
  __Pyx_XDECREF(__pyx_v_ship_accel_turn_rate);
  __Pyx_XDECREF(__pyx_v_ship_cruise_speed);
  __Pyx_XDECREF(__pyx_v_ship_cruise_turn_rate);
  __Pyx_XDECREF(__pyx_v_ship_cruise_timesteps);
  __Pyx_XDECREF(__pyx_v_maneuver_sim);
  __Pyx_XDECREF(__pyx_v_maneuver_fitness);
  __Pyx_XDECREF(__pyx_v_ship_is_stationary);
  __Pyx_XDECREF(__pyx_v_stationary_targetting_sim);
  __Pyx_XDECREF(__pyx_v_best_stationary_targetting_fitness);
  __Pyx_XDECREF(__pyx_v_imminent_asteroid_speed);
  __Pyx_XDECREF(__pyx_v_imminent_asteroid_relative_heading);
  __Pyx_XDECREF(__pyx_v_largest_gap_relative_heading);
  __Pyx_XDECREF(__pyx_v_nearby_asteroid_average_speed);
  __Pyx_XDECREF(__pyx_v_nearby_asteroid_count);
  __Pyx_XDECREF(__pyx_v_average_directional_speed);
  __Pyx_XDECREF(__pyx_v_total_asteroids_count);
  __Pyx_XDECREF(__pyx_v_current_asteroids_count);
  __Pyx_XDECREF(__pyx_v_ship_cruise_speed_mode);
  __Pyx_XDECREF(__pyx_v_ship_cruise_timesteps_mode);
  __Pyx_XDECREF(__pyx_v_ship_cruise_timesteps_float);
  __Pyx_XDECREF(__pyx_v_thrust_direction);
  __Pyx_XDECREF(__pyx_v_preview_move_sequence);
  __Pyx_XDECREF(__pyx_v_maneuver_fitness_breakdown);
  __Pyx_XDECREF(__pyx_gb_14neo_controller_13NeoController_11plan_action_2generator6);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_11 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_other_ships_exist, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 6240, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_base_state_is_exact, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 6240, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_iterations_boost, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 6240, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_plan_stationary, __pyx_mstate_global->__pyx_n_u_bool) < 0) __PYX_ERR(0, 6240, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < 0) __PYX_ERR(0, 6240, __pyx_L1_error)
  __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_25plan_action, 0, __pyx_mstate_global->__pyx_n_u_NeoController_plan_action, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[204])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_mstate_global->__pyx_tuple[93]);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_9, __pyx_t_11);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_plan_action, __pyx_t_9) < 0) __PYX_ERR(0, 6240, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
struct __pyx_obj_14neo_controller___pyx_scope_struct_14_plan_action {
  PyObject_HEAD
  PyObject *__pyx_v_self;
};

 6241:         #print("Calling plan action")

 6242:         # gc.disable()

 6243:         # Simulate and look for a good move

 6244:         # We have two options. Stay put and focus on targetting asteroids, or we can come up with an avoidance maneuver and target asteroids along the way if convenient

 6245:         # We simulate both options, and take the one with the higher fitness score

 6246:         # If we stay still, we can potentially keep shooting asteroids that are on collision course with us without having to move

 6247:         # But if we're overwhelmed, it may be a lot better to move to a safer spot

 6248:         # The third scenario is that even if we're safe where we are, we may be able to be on the offensive and seek out asteroids to lay mines, so that can also increase the fitness function of moving, making it better than staying still

 6249:         # Our number one priority is to stay alive. Second priority is to shoot as much as possible. And if we can, lay mines without putting ourselves in danger.

+6250:         assert self.game_state_to_base_planning is not None

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6250, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = (__pyx_t_1 != Py_None);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 6250, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 6250, __pyx_L1_error)
  #endif

+6251:         state_type = 'exact' if base_state_is_exact else 'predicted'

  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_base_state_is_exact); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6251, __pyx_L1_error)
  if (__pyx_t_2) {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_exact);
    __pyx_t_1 = __pyx_mstate_global->__pyx_n_u_exact;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_predicted);
    __pyx_t_1 = __pyx_mstate_global->__pyx_n_u_predicted;
  }
  __pyx_v_state_type = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 6252:         #index_according_to_lives_remaining = min(3, self.game_state_to_base_planning['ship_state'].lives_remaining)

+6253:         if self.game_state_to_base_planning['respawning']:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6253, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L3;
  }

 6254:             #print("Planning respawn maneuver")

 6255:             # Simulate and look for a good move

 6256:             # print(f"Checking for imminent danger. We're currently at position {ship_state.position[0]} {ship_state.position[1]}")

 6257:             # print(f"Current ship location: {ship_state.position[0]}, {ship_state.position[1]}, ship heading: {ship_state.heading}")

 6258: 

 6259:             # Check for danger

+6260:             MAX_CRUISE_SECONDS = 1.0 + 26.0*DELTA_TIME

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DELTA_TIME); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6260, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = PyNumber_Multiply(__pyx_mstate_global->__pyx_float_26_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6260, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyFloat_AddCObj(__pyx_mstate_global->__pyx_float_1_0, __pyx_t_1, 1.0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6260, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_MAX_CRUISE_SECONDS = __pyx_t_3;
    __pyx_t_3 = 0;

 6261:             # ship_random_range, ship_random_max_maneuver_length = get_simulated_ship_max_range(max_cruise_seconds)

 6262:             # print(f"Respawn maneuver max length: {ship_random_max_maneuver_length}s")

 6263: 

 6264:             #print("Looking for a respawn maneuver")

 6265:             # Run a simulation and find a course of action to put me to safety

+6266:             search_iterations_count = 0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_v_search_iterations_count = __pyx_mstate_global->__pyx_int_0;

 6267: 

 6268:             # while search_iterations_count < min_search_iterations or (not safe_maneuver_found and search_iterations_count < max_search_iterations):

 6269:             # for _ in range(search_iterations):

+6270:             while (search_iterations_count < get_min_respawn_per_timestep_search_iterations(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)) or self.performance_controller_check_whether_i_can_do_another_iteration()) and not search_iterations_count >= MAX_RESPAWN_PER_TIMESTEP_SEARCH_ITERATIONS:

    while (1) {
      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_min_respawn_per_timestep_sea); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_7 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_8))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
        assert(__pyx_t_7);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_9};
        __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6270, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
      }
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_t_6};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6270, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_search_iterations_count, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (!__pyx_t_11) {
      } else {
        goto __pyx_L7_next_and;
      }
      __pyx_t_3 = __pyx_cur_scope->__pyx_v_self;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_performance_controller_check_whe, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6270, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_11) {
      } else {
        __pyx_t_2 = __pyx_t_11;
        goto __pyx_L6_bool_binop_done;
      }
      __pyx_L7_next_and:;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MAX_RESPAWN_PER_TIMESTEP_SEARCH); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_search_iterations_count, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6270, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_12 = (!__pyx_t_11);
      __pyx_t_2 = __pyx_t_12;
      __pyx_L6_bool_binop_done:;
      if (!__pyx_t_2) break;

+6271:                 self.performance_controller_start_iteration()

      __pyx_t_4 = __pyx_cur_scope->__pyx_v_self;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_performance_controller_start_ite, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6271, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6272:                 search_iterations_count += 1

      __pyx_t_3 = __Pyx_PyLong_AddObjC(__pyx_v_search_iterations_count, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6272, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_search_iterations_count, __pyx_t_3);
      __pyx_t_3 = 0;

+6273:                 if search_iterations_count % 1 == 0:

      __pyx_t_3 = __Pyx_PyLong_RemainderObjC(__pyx_v_search_iterations_count, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6273, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6273, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_2) {
      }

 6274:                     # print(f"Respawn search iteration {search_iterations_count}")

 6275:                     pass

+6276:                 num_sims_this_planning_period = len(self.sims_this_planning_period)

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6276, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_13 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6276, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_v_num_sims_this_planning_period = __pyx_t_13;

+6277:                 if num_sims_this_planning_period == 0:

      switch (__pyx_v_num_sims_this_planning_period) {
        case 0:
/* … */
        break;
        case 1:

 6278:                     # On the first iteration, try the null action. For ring scenarios, it may be best to stay at the center of the ring.

 6279:                     # TODO: RESTORE NULL ACTION

+6280:                     random_ship_heading_angle = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_random_ship_heading_angle, __pyx_mstate_global->__pyx_float_0_0);

+6281:                     ship_accel_turn_rate = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_float_0_0);

+6282:                     ship_cruise_speed = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_float_0_0);

+6283:                     ship_cruise_turn_rate = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_float_0_0);

+6284:                     ship_cruise_timesteps = 0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_int_0);

+6285:                 elif num_sims_this_planning_period == 1:

        break;
        case 2:

 6286:                     # TODO: Use this opportunity to aim at an asteroid! But we need to do something to get it to shoot, so maybe this won't work with our current framework rip.

 6287:                     # On the second iteration, try staying still for 1 second (and just turn a little bit so we can use the same framework to do this null movement with a wait)

+6288:                     random_ship_heading_angle = 180.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_180_0);
        __Pyx_XDECREF_SET(__pyx_v_random_ship_heading_angle, __pyx_mstate_global->__pyx_float_180_0);

+6289:                     ship_accel_turn_rate = 180.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_180_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_float_180_0);

+6290:                     ship_cruise_speed = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_float_0_0);

+6291:                     ship_cruise_turn_rate = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_float_0_0);

+6292:                     ship_cruise_timesteps = 0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_int_0);

+6293:                 elif num_sims_this_planning_period == 2:

        break;
        default:

 6294:                     # TODO: Use this opportunity to aim at an asteroid!

 6295:                     # On the third iteration, try staying still for 2 seconds (and just turn a little bit so we can use the same framework to do this null movement with a wait)

+6296:                     random_ship_heading_angle = 180.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_180_0);
        __Pyx_XDECREF_SET(__pyx_v_random_ship_heading_angle, __pyx_mstate_global->__pyx_float_180_0);

+6297:                     ship_accel_turn_rate = 90.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_90_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_accel_turn_rate, __pyx_mstate_global->__pyx_float_90_0);

+6298:                     ship_cruise_speed = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_speed, __pyx_mstate_global->__pyx_float_0_0);

+6299:                     ship_cruise_turn_rate = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_float_0_0);

+6300:                     ship_cruise_timesteps = 0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps, __pyx_mstate_global->__pyx_int_0);

 6301:                 else:

+6302:                     random_ship_heading_angle = random.uniform(-20.0, 20.0)

        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6302, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_uniform); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6302, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[29], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6302, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF_SET(__pyx_v_random_ship_heading_angle, __pyx_t_3);
        __pyx_t_3 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[29] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_float_neg_20_0, __pyx_mstate_global->__pyx_float_20_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[29])) __PYX_ERR(0, 6302, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[29]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[29]);

+6303:                     ship_accel_turn_rate = random.uniform(-SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE)

        __pyx_t_4 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6303, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_uniform); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6303, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6303, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_1 = PyNumber_Negative(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6303, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6303, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_5))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
          assert(__pyx_t_4);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_6};
          __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6303, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __Pyx_XDECREF_SET(__pyx_v_ship_accel_turn_rate, __pyx_t_3);
        __pyx_t_3 = 0;

+6304:                     ship_cruise_speed = SHIP_MAX_SPEED*random.choice([-1, 1])

        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6304, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_6 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6304, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choice); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6304, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6304, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1);
        __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1);
        if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 6304, __pyx_L1_error);
        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
        __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1);
        if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 6304, __pyx_L1_error);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_6);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_6);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1};
          __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6304, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
        }
        __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6304, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_speed, __pyx_t_4);
        __pyx_t_4 = 0;

+6305:                     ship_cruise_turn_rate = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_turn_rate, __pyx_mstate_global->__pyx_float_0_0);

+6306:                     ship_cruise_timesteps = random.randint(0, round(MAX_CRUISE_SECONDS*FPS))

        __pyx_t_5 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6306, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6306, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_6 = NULL;
        __Pyx_INCREF(__pyx_builtin_round);
        __pyx_t_8 = __pyx_builtin_round; 
        __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6306, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_7 = PyNumber_Multiply(__pyx_v_MAX_CRUISE_SECONDS, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6306, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_10 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_7};
          __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6306, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_1))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
          assert(__pyx_t_5);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0, __pyx_t_3};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6306, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps, __pyx_t_4);
        __pyx_t_4 = 0;
        break;
      }

+6307:                 if ENABLE_SANITY_CHECKS and not (bool(self.game_state_to_base_planning['ship_respawn_timer']) == self.game_state_to_base_planning['ship_state'].is_respawning):  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_12) {
      } else {
        __pyx_t_2 = __pyx_t_12;
        goto __pyx_L11_bool_binop_done;
      }
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_12))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6307, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_11 = (!__pyx_t_12);
      __pyx_t_2 = __pyx_t_11;
      __pyx_L11_bool_binop_done:;
      if (__pyx_t_2) {
/* … */
      }

+6308:                     print(f"BAD, self.game_state_to_base_planning['ship_respawn_timer']: {self.game_state_to_base_planning['ship_respawn_timer']}, self.game_state_to_base_planning['ship_state'].is_respawning: {self.game_state_to_base_planning['ship_state'].is_respawning}")  # REMOVE_FOR_COMPETITION

        __pyx_t_4 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_1 = __pyx_builtin_print; 
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_7 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_14[0] = __pyx_mstate_global->__pyx_kp_u_BAD_self_game_state_to_base_plan;
        __pyx_t_14[1] = __pyx_t_5;
        __pyx_t_14[2] = __pyx_mstate_global->__pyx_kp_u_self_game_state_to_base_plannin;
        __pyx_t_14[3] = __pyx_t_7;
        __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_14, 4, 61 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 64 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7));
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6308, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_10 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_8};
          __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6308, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 6309:                 # TODO: There's a hardcoded false in the arguments to the following sim. Investigate!!!

 6310:                 #print(f"Doing respawn maneuver with {random_ship_heading_angle=} {ship_accel_turn_rate=} {ship_cruise_speed=} {ship_cruise_turn_rate=} {ship_cruise_timesteps=}")

+6311:                 assert not self.game_state_to_base_planning['fire_next_timestep_flag']  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6311, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6311, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6311, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_11 = (!__pyx_t_2);
        if (unlikely(!__pyx_t_11)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6311, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6311, __pyx_L1_error)
      #endif

+6312:                 maneuver_sim = Matrix(game_state=self.game_state_to_base_planning['game_state'],

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6312, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6312, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_7 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6312, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6313:                                       ship_state=self.game_state_to_base_planning['ship_state'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6313, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6313, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6314:                                       initial_timestep=self.game_state_to_base_planning['timestep'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6314, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6314, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6315:                                       respawn_timer=self.game_state_to_base_planning['ship_respawn_timer'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6315, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6315, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6316:                                       asteroids_pending_death=self.game_state_to_base_planning['asteroids_pending_death'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6316, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6316, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6317:                                       forecasted_asteroid_splits=self.game_state_to_base_planning['forecasted_asteroid_splits'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6317, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_16 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6317, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_16);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6318:                                       last_timestep_fired=self.game_state_to_base_planning['last_timestep_fired'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6318, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6318, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6319:                                       last_timestep_mined=self.game_state_to_base_planning['last_timestep_mined'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6319, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_18 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 6319, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6320:                                       mine_positions_placed=self.game_state_to_base_planning['mine_positions_placed'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6320, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_19 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6320, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 6321:                                       halt_shooting=True,

 6322:                                       fire_first_timestep=False and self.game_state_to_base_planning['fire_next_timestep_flag'],

 6323:                                       verify_first_shot=False,

 6324:                                       verify_maneuver_shots=False,

+6325:                                       game_state_plotter=self.game_state_plotter)

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6325, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_8))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 14 : 0)] = {__pyx_t_3, NULL};
        __pyx_t_20 = __Pyx_MakeVectorcallBuilderKwds(14); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6312, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, __pyx_t_7, __pyx_t_20, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_5, __pyx_t_20, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_t_6, __pyx_t_20, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_9, __pyx_t_20, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_15, __pyx_t_20, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_16, __pyx_t_20, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_17, __pyx_t_20, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_18, __pyx_t_20, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_19, __pyx_t_20, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_halt_shooting, Py_True, __pyx_t_20, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_first_timestep, Py_False, __pyx_t_20, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_first_shot, Py_False, __pyx_t_20, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, Py_False, __pyx_t_20, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_t_4, __pyx_t_20, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 6312, __pyx_L1_error)
        __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_8, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_20);
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6312, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_XDECREF_SET(__pyx_v_maneuver_sim, __pyx_t_1);
      __pyx_t_1 = 0;

 6326:                 # This statement's a doozy. We evaluate left to right, and once it returns false, we stop going.

+6327:                 (maneuver_sim.rotate_heading(random_ship_heading_angle) and maneuver_sim.accelerate(ship_cruise_speed, ship_accel_turn_rate) and maneuver_sim.cruise(ship_cruise_timesteps, ship_cruise_turn_rate) and maneuver_sim.accelerate(0))

      __pyx_t_20 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_20);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_v_random_ship_heading_angle};
        __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_rotate_heading, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6327, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6327, __pyx_L1_error)
      if (__pyx_t_11) {
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      } else {
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_1 = __pyx_t_8;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        goto __pyx_L13_bool_binop_done;
      }
      __pyx_t_20 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_20);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_20, __pyx_v_ship_cruise_speed, __pyx_v_ship_accel_turn_rate};
        __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_accelerate, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6327, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6327, __pyx_L1_error)
      if (__pyx_t_11) {
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      } else {
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_1 = __pyx_t_8;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        goto __pyx_L13_bool_binop_done;
      }
      __pyx_t_20 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_20);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_20, __pyx_v_ship_cruise_timesteps, __pyx_v_ship_cruise_turn_rate};
        __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_cruise, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6327, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6327, __pyx_L1_error)
      if (__pyx_t_11) {
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      } else {
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_1 = __pyx_t_8;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        goto __pyx_L13_bool_binop_done;
      }
      __pyx_t_20 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_20);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_mstate_global->__pyx_int_0};
        __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_accelerate, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6327, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_1 = __pyx_t_8;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_L13_bool_binop_done:;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6328:                     # The ship went through all the steps without colliding

 6329:                     #debug_print("The ship went through all the steps without colliding")

 6330:                     # maneuver_complete_without_crash = True

 6331:                 #else:

 6332:                     # The ship crashed somewhere before reaching the final resting spot

 6333:                     #debug_print("The ship crashed somewhere before reaching the final resting spot")

 6334:                 #print(f"Move seq: {maneuver_sim.get_move_sequence()}")

+6335:                 maneuver_fitness = maneuver_sim.get_fitness()

      __pyx_t_8 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6335, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_XDECREF_SET(__pyx_v_maneuver_fitness, __pyx_t_1);
      __pyx_t_1 = 0;

 6336:                 #print(f"Respawn maneuver fitness: {maneuver_fitness} {maneuver_sim.get_fitness_breakdown()}, move seq length was {len(maneuver_sim.get_move_sequence())}")

 6337: 

+6338:                 self.sims_this_planning_period.append({

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6338, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
/* … */
      __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_t_8); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 6338, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+6339:                     'sim': maneuver_sim,

      __pyx_t_8 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6339, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_sim, __pyx_v_maneuver_sim) < 0) __PYX_ERR(0, 6339, __pyx_L1_error)

+6340:                     'fitness': maneuver_fitness,

      if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_fitness, __pyx_v_maneuver_fitness) < 0) __PYX_ERR(0, 6339, __pyx_L1_error)

+6341:                     'fitness_breakdown': maneuver_sim.get_fitness_breakdown(),

      __pyx_t_4 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
        __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness_breakdown, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6341, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
      }
      if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_fitness_breakdown, __pyx_t_20) < 0) __PYX_ERR(0, 6339, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_action_type, __pyx_mstate_global->__pyx_n_u_respawn) < 0) __PYX_ERR(0, 6339, __pyx_L1_error)

 6342:                     'action_type': 'respawn',

+6343:                     'state_type': state_type,

      if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_state_type, __pyx_v_state_type) < 0) __PYX_ERR(0, 6339, __pyx_L1_error)

+6344:                     'maneuver_tuple': (random_ship_heading_angle, ship_cruise_speed, ship_accel_turn_rate, ship_cruise_timesteps, ship_cruise_turn_rate)

      __pyx_t_20 = PyTuple_New(5); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6344, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_INCREF(__pyx_v_random_ship_heading_angle);
      __Pyx_GIVEREF(__pyx_v_random_ship_heading_angle);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_v_random_ship_heading_angle) != (0)) __PYX_ERR(0, 6344, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_cruise_speed);
      __Pyx_GIVEREF(__pyx_v_ship_cruise_speed);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 1, __pyx_v_ship_cruise_speed) != (0)) __PYX_ERR(0, 6344, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_accel_turn_rate);
      __Pyx_GIVEREF(__pyx_v_ship_accel_turn_rate);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 2, __pyx_v_ship_accel_turn_rate) != (0)) __PYX_ERR(0, 6344, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_cruise_timesteps);
      __Pyx_GIVEREF(__pyx_v_ship_cruise_timesteps);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 3, __pyx_v_ship_cruise_timesteps) != (0)) __PYX_ERR(0, 6344, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_cruise_turn_rate);
      __Pyx_GIVEREF(__pyx_v_ship_cruise_turn_rate);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_20, 4, __pyx_v_ship_cruise_turn_rate) != (0)) __PYX_ERR(0, 6344, __pyx_L1_error);
      if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_maneuver_tuple, __pyx_t_20) < 0) __PYX_ERR(0, 6339, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

 6345:                 })

+6346:                 if maneuver_fitness > self.best_fitness_this_planning_period:

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6346, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_1 = PyObject_RichCompare(__pyx_v_maneuver_fitness, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6346, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6346, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__pyx_t_11) {
/* … */
      }
    }

+6347:                     self.second_best_fitness_this_planning_period = self.best_fitness_this_planning_period

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6347, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_1) < 0) __PYX_ERR(0, 6347, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6348:                     self.second_best_fitness_this_planning_period_index = self.best_fitness_this_planning_period_index

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6348, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_1) < 0) __PYX_ERR(0, 6348, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6349: 

+6350:                     self.best_fitness_this_planning_period = maneuver_fitness

        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_v_maneuver_fitness) < 0) __PYX_ERR(0, 6350, __pyx_L1_error)

+6351:                     self.best_fitness_this_planning_period_index = len(self.sims_this_planning_period) - 1

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6351, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_13 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6351, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyLong_FromSsize_t((__pyx_t_13 - 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6351, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_1) < 0) __PYX_ERR(0, 6351, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6352:         else:

 6353:             # Non-respawn move

 6354: 

 6355:             # Stationary targetting simulation

 6356:             #assert self.game_state_to_base_planning is not None

+6357:             if self.base_gamestate_analysis is None:

  /*else*/ {
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestate_analysis); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6357, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_11 = (__pyx_t_1 == Py_None);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_11) {
/* … */
    }

+6358:                 self.base_gamestate_analysis = analyze_gamestate_for_heuristic_maneuver(self.game_state_to_base_planning['game_state'], self.game_state_to_base_planning['ship_state'])

      __pyx_t_8 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_analyze_gamestate_for_heuristic_5); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6358, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6358, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_19 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6358, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6358, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_18 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 6358, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_20))) {
        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_20);
        assert(__pyx_t_8);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_20);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_20, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_19, __pyx_t_18};
        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_20, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6358, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestate_analysis, __pyx_t_1) < 0) __PYX_ERR(0, 6358, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6359:             ship_is_stationary = is_close_to_zero(self.game_state_to_base_planning['ship_state'].speed)

    __pyx_t_20 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_is_close_to_zero); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 6359, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6359, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6359, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6359, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_10 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_18))) {
      __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_18);
      assert(__pyx_t_20);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18);
      __Pyx_INCREF(__pyx_t_20);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_18, __pyx__function);
      __pyx_t_10 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_t_19};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_18, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6359, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_ship_is_stationary = __pyx_t_1;
    __pyx_t_1 = 0;

+6360:             if plan_stationary and self.game_state_to_base_planning['ship_state'].bullets_remaining != 0 and ship_is_stationary:

    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_plan_stationary); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6360, __pyx_L1_error)
    if (__pyx_t_2) {
    } else {
      __pyx_t_11 = __pyx_t_2;
      goto __pyx_L20_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6360, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_18 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 6360, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_18);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_bullets_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6360, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __pyx_t_2 = (__Pyx_PyLong_BoolNeObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6360, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_2) {
    } else {
      __pyx_t_11 = __pyx_t_2;
      goto __pyx_L20_bool_binop_done;
    }
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_ship_is_stationary); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6360, __pyx_L1_error)
    __pyx_t_11 = __pyx_t_2;
    __pyx_L20_bool_binop_done:;
    if (__pyx_t_11) {
/* … */
    }

 6361:                 # No need to check whether this is allowed, because we need to do this iteration at minimum

+6362:                 self.performance_controller_start_iteration()

      __pyx_t_18 = __pyx_cur_scope->__pyx_v_self;
      __Pyx_INCREF(__pyx_t_18);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_18, NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_performance_controller_start_ite, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6362, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6363:                 # The first list element is the stationary targetting

 6364:                 # print('game state to base planning:')

 6365:                 # print(self.game_state_to_base_planning)

 6366:                 # debug_print('Stationary sim ast pending death:')

 6367:                 # debug_print(self.game_state_to_base_planning['asteroids_pending_death'])

+6368:                 stationary_targetting_sim = Matrix(game_state=self.game_state_to_base_planning['game_state'],

      __pyx_t_18 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6368, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6368, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6368, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6369:                                                    ship_state=self.game_state_to_base_planning['ship_state'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6369, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6369, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6370:                                                    initial_timestep=self.game_state_to_base_planning['timestep'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6371:                                                    respawn_timer=self.game_state_to_base_planning['ship_respawn_timer'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6371, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_16 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6371, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_16);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6372:                                                    asteroids_pending_death=self.game_state_to_base_planning['asteroids_pending_death'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6372, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6372, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6373:                                                    forecasted_asteroid_splits=self.game_state_to_base_planning['forecasted_asteroid_splits'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6373, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6373, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6374:                                                    last_timestep_fired=self.game_state_to_base_planning['last_timestep_fired'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6374, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6374, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6375:                                                    last_timestep_mined=self.game_state_to_base_planning['last_timestep_mined'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6375, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6375, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6376:                                                    mine_positions_placed=self.game_state_to_base_planning['mine_positions_placed'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6376, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_7 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6376, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

 6377:                                                    halt_shooting=False,

+6378:                                                    fire_first_timestep=self.game_state_to_base_planning['fire_next_timestep_flag'],

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6378, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6378, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6379:                                                    verify_first_shot=True if len(self.sims_this_planning_period) == 0 and other_ships_exist else False,

      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6379, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_13 = PyObject_Length(__pyx_t_22); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6379, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_2 = (__pyx_t_13 == 0);
      if (__pyx_t_2) {
      } else {
        __pyx_t_11 = __pyx_t_2;
        goto __pyx_L23_bool_binop_done;
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_other_ships_exist); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6379, __pyx_L1_error)
      __pyx_t_11 = __pyx_t_2;
      __pyx_L23_bool_binop_done:;
      if (__pyx_t_11) {
        __Pyx_INCREF(Py_True);
        __pyx_t_20 = Py_True;
      } else {
        __Pyx_INCREF(Py_False);
        __pyx_t_20 = Py_False;
      }

 6380:                                                    verify_maneuver_shots=False,

+6381:                                                    game_state_plotter=self.game_state_plotter)

      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6381, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_19))) {
        __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_19);
        assert(__pyx_t_18);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19);
        __Pyx_INCREF(__pyx_t_18);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_19, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 14 : 0)] = {__pyx_t_18, NULL};
        __pyx_t_23 = __Pyx_MakeVectorcallBuilderKwds(14); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6368, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, __pyx_t_8, __pyx_t_23, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_4, __pyx_t_23, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_t_17, __pyx_t_23, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_16, __pyx_t_23, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_15, __pyx_t_23, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_9, __pyx_t_23, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_6, __pyx_t_23, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_5, __pyx_t_23, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_7, __pyx_t_23, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_halt_shooting, Py_False, __pyx_t_23, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_t_3, __pyx_t_23, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_first_shot, __pyx_t_20, __pyx_t_23, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, Py_False, __pyx_t_23, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_t_22, __pyx_t_23, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 6368, __pyx_L1_error)
        __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_19, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_23);
        __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6368, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_v_stationary_targetting_sim = __pyx_t_1;
      __pyx_t_1 = 0;

+6382:                 stationary_targetting_sim.target_selection()

      __pyx_t_19 = __pyx_v_stationary_targetting_sim;
      __Pyx_INCREF(__pyx_t_19);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_19, NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_target_selection, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6382, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6383:                 #print('\nstationary targetting sim move seq')

 6384:                 #print(stationary_targetting_sim.get_move_sequence())

 6385: 

+6386:                 best_stationary_targetting_fitness = stationary_targetting_sim.get_fitness()

      __pyx_t_19 = __pyx_v_stationary_targetting_sim;
      __Pyx_INCREF(__pyx_t_19);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_19, NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6386, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_v_best_stationary_targetting_fitness = __pyx_t_1;
      __pyx_t_1 = 0;

+6387:                 if len(self.sims_this_planning_period) == 0:

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6387, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_13 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6387, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_11 = (__pyx_t_13 == 0);
      if (__pyx_t_11) {
/* … */
      }

+6388:                     if stationary_targetting_sim.get_cancel_firing_first_timestep():

        __pyx_t_19 = __pyx_v_stationary_targetting_sim;
        __Pyx_INCREF(__pyx_t_19);
        __pyx_t_10 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_19, NULL};
          __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_cancel_firing_first_timestep, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6388, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6388, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (__pyx_t_11) {
/* … */
        }

 6389:                         # The plan was to first at the first timestep this planning period. However, due to non-determinism caused by the existence of another ship, this shot would actually miss. We checked and caught this, so we're going to just nix the idea of shooting on the first timestep.

+6390:                         assert self.game_state_to_base_planning['fire_next_timestep_flag']  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6390, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_19 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6390, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_19);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6390, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
            if (unlikely(!__pyx_t_11)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 6390, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 6390, __pyx_L1_error)
          #endif

+6391:                         self.game_state_to_base_planning['fire_next_timestep_flag'] = False

          __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6391, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_19);
          if (unlikely((PyObject_SetItem(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0))) __PYX_ERR(0, 6391, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

 6392: 

+6393:                 self.sims_this_planning_period.append({

      __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6393, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
/* … */
      __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_19, __pyx_t_1); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 6393, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6394:                     'sim': stationary_targetting_sim,

      __pyx_t_1 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6394, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_sim, __pyx_v_stationary_targetting_sim) < 0) __PYX_ERR(0, 6394, __pyx_L1_error)

+6395:                     'fitness': best_stationary_targetting_fitness,

      if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fitness, __pyx_v_best_stationary_targetting_fitness) < 0) __PYX_ERR(0, 6394, __pyx_L1_error)

+6396:                     'fitness_breakdown': stationary_targetting_sim.get_fitness_breakdown(),

      __pyx_t_22 = __pyx_v_stationary_targetting_sim;
      __Pyx_INCREF(__pyx_t_22);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_22, NULL};
        __pyx_t_23 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness_breakdown, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
        if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6396, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_23);
      }
      if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_fitness_breakdown, __pyx_t_23) < 0) __PYX_ERR(0, 6394, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_action_type, __pyx_mstate_global->__pyx_n_u_targetting) < 0) __PYX_ERR(0, 6394, __pyx_L1_error)

 6397:                     'action_type': 'targetting',

+6398:                     'state_type': state_type,

      if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_state_type, __pyx_v_state_type) < 0) __PYX_ERR(0, 6394, __pyx_L1_error)

+6399:                     'maneuver_tuple': None,

      if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_maneuver_tuple, Py_None) < 0) __PYX_ERR(0, 6394, __pyx_L1_error)

 6400:                 })

+6401:                 self.stationary_targetting_sim_index = len(self.sims_this_planning_period) - 1

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6401, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_13 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6401, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = PyLong_FromSsize_t((__pyx_t_13 - 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6401, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index, __pyx_t_1) < 0) __PYX_ERR(0, 6401, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6402:                 if best_stationary_targetting_fitness > self.best_fitness_this_planning_period:

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6402, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_19 = PyObject_RichCompare(__pyx_v_best_stationary_targetting_fitness, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6402, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6402, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      if (__pyx_t_11) {
/* … */
      }

+6403:                     self.second_best_fitness_this_planning_period = self.best_fitness_this_planning_period

        __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6403, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_19) < 0) __PYX_ERR(0, 6403, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

+6404:                     self.second_best_fitness_this_planning_period_index = self.best_fitness_this_planning_period_index

        __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6404, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_19) < 0) __PYX_ERR(0, 6404, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

 6405: 

+6406:                     self.best_fitness_this_planning_period = best_stationary_targetting_fitness

        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_v_best_stationary_targetting_fitness) < 0) __PYX_ERR(0, 6406, __pyx_L1_error)

+6407:                     self.best_fitness_this_planning_period_index = self.stationary_targetting_sim_index

        __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stationary_targetting_sim_index); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6407, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_19) < 0) __PYX_ERR(0, 6407, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

 6408: 

 6409:                 # debug_print(f"Planning targetting, and got fitness {best_stationary_targetting_fitness}")

+6410:             if plan_stationary and not ship_is_stationary:  # REMOVE_FOR_COMPETITION

    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_plan_stationary); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6410, __pyx_L1_error)
    if (__pyx_t_2) {
    } else {
      __pyx_t_11 = __pyx_t_2;
      goto __pyx_L29_bool_binop_done;
    }
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_ship_is_stationary); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6410, __pyx_L1_error)
    __pyx_t_12 = (!__pyx_t_2);
    __pyx_t_11 = __pyx_t_12;
    __pyx_L29_bool_binop_done:;
    if (__pyx_t_11) {
/* … */
    }

+6411:                 print(f"\nWARNING: The ship wasn't stationary after the last maneuver, so we're skipping stationary targeting! Our planning period starts on ts {self.game_state_to_base_planning['timestep']}")  # REMOVE_FOR_COMPETITION

      __pyx_t_1 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_23 = __pyx_builtin_print; 
      __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6411, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __pyx_t_20 = __Pyx_PyObject_Dict_GetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6411, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_22 = __Pyx_PyObject_FormatSimple(__pyx_t_20, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6411, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_20 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_WARNING_The_ship_wasn_t_station, __pyx_t_22); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6411, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __pyx_t_10 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_20};
        __pyx_t_19 = __Pyx_PyObject_FastCall(__pyx_t_23, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6411, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
      }
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

 6412:             # Try moving! Run a simulation and find a course of action to put me to safety

 6413:             '''

 6414:             if other_ships_exist:

 6415:                 if isinf(self.best_fitness_this_planning_period):

 6416:                     # This is the first timestep we're planning for this period, so we don't really know how many iterations to use. Don't go all out on this first one in case it's an easy one.

 6417:                     search_iterations = 2

 6418:                 elif self.best_fitness_this_planning_period > 0.9:

 6419:                     search_iterations = 1

 6420:                 elif self.best_fitness_this_planning_period > 0.8:

 6421:                     search_iterations = 1

 6422:                 elif self.best_fitness_this_planning_period > 0.7:

 6423:                     search_iterations = 2

 6424:                 elif self.best_fitness_this_planning_period > 0.6:

 6425:                     search_iterations = 3

 6426:                 elif self.best_fitness_this_planning_period > 0.5:

 6427:                     search_iterations = 4

 6428:                 elif self.best_fitness_this_planning_period > 0.4:

 6429:                     search_iterations = 5

 6430:                 else:

 6431:                     search_iterations = 6

 6432:             else:

 6433:                 if isinf(self.best_fitness_this_planning_period) and self.game_state_to_base_planning['ship_state'].bullets_remaining != 0:

 6434:                     raise Exception("If there's no ships, why don't we have any sims this planning period yet? We should have done stationary first.")

 6435:                     # This is the first timestep we're planning for this period, so we don't really know how many iterations to use. Don't go all out on this first one in case it's an easy one.

 6436:                     search_iterations = 2

 6437:                 elif self.best_fitness_this_planning_period > 0.9:

 6438:                     search_iterations = 1

 6439:                 elif self.best_fitness_this_planning_period > 0.8:

 6440:                     search_iterations = 1

 6441:                 elif self.best_fitness_this_planning_period > 0.7:

 6442:                     search_iterations = 2

 6443:                 elif self.best_fitness_this_planning_period > 0.6:

 6444:                     search_iterations = 3

 6445:                 elif self.best_fitness_this_planning_period > 0.5:

 6446:                     search_iterations = 4

 6447:                 elif self.best_fitness_this_planning_period > 0.4:

 6448:                     search_iterations = 5

 6449:                 else:

 6450:                     search_iterations = 6

 6451:             '''

 6452: 

 6453:             '''

 6454:             if iterations_boost:

 6455:                 search_iterations = min(80, (search_iterations + 1)*10)

 6456: 

 6457:             if self.game_state_to_base_planning['ship_state'].lives_remaining == 1:

 6458:                 # When down to our last life, try twice as hard to survive

 6459:                 search_iterations *= 2

 6460:             elif self.game_state_to_base_planning['ship_state'].lives_remaining == 2:

 6461:                 search_iterations = floor(search_iterations*1.5)

 6462:             '''

+6463:             if (len(self.sims_this_planning_period) == 0 or (len(self.sims_this_planning_period) == 1 and self.sims_this_planning_period[0]['action_type'] != 'heuristic_maneuver')) and ship_is_stationary:

    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_13 = PyObject_Length(__pyx_t_19); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_12 = (__pyx_t_13 == 0);
    if (!__pyx_t_12) {
    } else {
      goto __pyx_L33_next_and;
    }
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_13 = PyObject_Length(__pyx_t_19); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_12 = (__pyx_t_13 == 1);
    if (__pyx_t_12) {
    } else {
      __pyx_t_11 = __pyx_t_12;
      goto __pyx_L32_bool_binop_done;
    }
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_23 = __Pyx_GetItemInt(__pyx_t_19, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_23);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_19 = __Pyx_PyObject_Dict_GetItem(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_action_type); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
    __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_heuristic_maneuver, Py_NE)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6463, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_12) {
    } else {
      __pyx_t_11 = __pyx_t_12;
      goto __pyx_L32_bool_binop_done;
    }
    __pyx_L33_next_and:;
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_ship_is_stationary); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6463, __pyx_L1_error)
    __pyx_t_11 = __pyx_t_12;
    __pyx_L32_bool_binop_done:;
    if (__pyx_t_11) {
/* … */
      goto __pyx_L31;
    }

+6464:                 heuristic_maneuver = True

      __pyx_v_heuristic_maneuver = 1;

 6465:             else:

+6466:                 heuristic_maneuver = False

    /*else*/ {
      __pyx_v_heuristic_maneuver = 0;
    }
    __pyx_L31:;

 6467: 

+6468:             imminent_asteroid_speed, imminent_asteroid_relative_heading, largest_gap_relative_heading, nearby_asteroid_average_speed, nearby_asteroid_count, average_directional_speed, total_asteroids_count, current_asteroids_count = self.base_gamestate_analysis

    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestate_analysis); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6468, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    if ((likely(PyTuple_CheckExact(__pyx_t_19))) || (PyList_CheckExact(__pyx_t_19))) {
      PyObject* sequence = __pyx_t_19;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 8)) {
        if (size > 8) __Pyx_RaiseTooManyValuesError(8);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 6468, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_23 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_23);
        __pyx_t_20 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_20);
        __pyx_t_1 = PyTuple_GET_ITEM(sequence, 2);
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_22 = PyTuple_GET_ITEM(sequence, 3);
        __Pyx_INCREF(__pyx_t_22);
        __pyx_t_3 = PyTuple_GET_ITEM(sequence, 4);
        __Pyx_INCREF(__pyx_t_3);
        __pyx_t_7 = PyTuple_GET_ITEM(sequence, 5);
        __Pyx_INCREF(__pyx_t_7);
        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 6);
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 7);
        __Pyx_INCREF(__pyx_t_6);
      } else {
        __pyx_t_23 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_23);
        __pyx_t_20 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_20);
        __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 2);
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_1);
        __pyx_t_22 = __Pyx_PyList_GetItemRef(sequence, 3);
        if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_22);
        __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 4);
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_3);
        __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 5);
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_7);
        __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 6);
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_5);
        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 7);
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6468, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_6);
      }
      #else
      {
        Py_ssize_t i;
        PyObject** temps[8] = {&__pyx_t_23,&__pyx_t_20,&__pyx_t_1,&__pyx_t_22,&__pyx_t_3,&__pyx_t_7,&__pyx_t_5,&__pyx_t_6};
        for (i=0; i < 8; i++) {
          PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 6468, __pyx_L1_error)
          __Pyx_GOTREF(item);
          *(temps[i]) = item;
        }
      }
      #endif
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    } else {
      Py_ssize_t index = -1;
      PyObject** temps[8] = {&__pyx_t_23,&__pyx_t_20,&__pyx_t_1,&__pyx_t_22,&__pyx_t_3,&__pyx_t_7,&__pyx_t_5,&__pyx_t_6};
      __pyx_t_9 = PyObject_GetIter(__pyx_t_19); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6468, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __pyx_t_24 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9);
      for (index=0; index < 8; index++) {
        PyObject* item = __pyx_t_24(__pyx_t_9); if (unlikely(!item)) goto __pyx_L36_unpacking_failed;
        __Pyx_GOTREF(item);
        *(temps[index]) = item;
      }
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_24(__pyx_t_9), 8) < 0) __PYX_ERR(0, 6468, __pyx_L1_error)
      __pyx_t_24 = NULL;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      goto __pyx_L37_unpacking_done;
      __pyx_L36_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_24 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 6468, __pyx_L1_error)
      __pyx_L37_unpacking_done:;
    }
    __pyx_v_imminent_asteroid_speed = __pyx_t_23;
    __pyx_t_23 = 0;
    __pyx_v_imminent_asteroid_relative_heading = __pyx_t_20;
    __pyx_t_20 = 0;
    __pyx_v_largest_gap_relative_heading = __pyx_t_1;
    __pyx_t_1 = 0;
    __pyx_v_nearby_asteroid_average_speed = __pyx_t_22;
    __pyx_t_22 = 0;
    __pyx_v_nearby_asteroid_count = __pyx_t_3;
    __pyx_t_3 = 0;
    __pyx_v_average_directional_speed = __pyx_t_7;
    __pyx_t_7 = 0;
    __pyx_v_total_asteroids_count = __pyx_t_5;
    __pyx_t_5 = 0;
    __pyx_v_current_asteroids_count = __pyx_t_6;
    __pyx_t_6 = 0;

 6469: 

 6470:             # Let's just pretend the following is a fuzzy system lol

 6471:             # For performance and simplicity, I'll just use a bunch of if statements

+6472:             if average_directional_speed > 80 and current_asteroids_count > 5 and total_asteroids_count >= 100:

    __pyx_t_19 = PyObject_RichCompare(__pyx_v_average_directional_speed, __pyx_mstate_global->__pyx_int_80, Py_GT); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6472, __pyx_L1_error)
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6472, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_12) {
    } else {
      __pyx_t_11 = __pyx_t_12;
      goto __pyx_L39_bool_binop_done;
    }
    __pyx_t_19 = PyObject_RichCompare(__pyx_v_current_asteroids_count, __pyx_mstate_global->__pyx_int_5, Py_GT); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6472, __pyx_L1_error)
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6472, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_12) {
    } else {
      __pyx_t_11 = __pyx_t_12;
      goto __pyx_L39_bool_binop_done;
    }
    __pyx_t_19 = PyObject_RichCompare(__pyx_v_total_asteroids_count, __pyx_mstate_global->__pyx_int_100, Py_GE); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6472, __pyx_L1_error)
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6472, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_11 = __pyx_t_12;
    __pyx_L39_bool_binop_done:;
    if (__pyx_t_11) {
/* … */
      goto __pyx_L38;
    }

 6473:                 # This is probably a wall scenario! We have many asteroids all travelling in basically the same direction

+6474:                 print_explanation(f"Wall scenario detected! Preferring trying longer cruise lengths", self.current_timestep)

      __pyx_t_6 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6474, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6474, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_6);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_Wall_scenario_detected_Preferrin, __pyx_t_7};
        __pyx_t_19 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6474, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
      }
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

+6475:                 ship_cruise_speed_mode = SHIP_MAX_SPEED

      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6475, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_v_ship_cruise_speed_mode = __pyx_t_19;
      __pyx_t_19 = 0;

+6476:                 ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS

      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_MAX_CRUISE_TIMESTEPS); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6476, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_v_ship_cruise_timesteps_mode = __pyx_t_19;
      __pyx_t_19 = 0;

+6477:                 max_pre_maneuver_turn_timesteps = 6.0

      __pyx_v_max_pre_maneuver_turn_timesteps = 6.0;

+6478:             elif any(m.position in self.game_state_to_base_planning['mine_positions_placed'] for m in self.game_state_to_base_planning['game_state'].mines):

static PyObject *__pyx_pf_14neo_controller_13NeoController_11plan_action_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_14neo_controller___pyx_scope_struct_15_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_15_genexpr *)__pyx_tp_new_14neo_controller___pyx_scope_struct_15_genexpr(__pyx_mstate_global->__pyx_ptype_14neo_controller___pyx_scope_struct_15_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_14neo_controller___pyx_scope_struct_15_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 6478, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_14neo_controller___pyx_scope_struct_14_plan_action *) __pyx_self;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_14neo_controller_13NeoController_11plan_action_2generator6, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_NeoController_plan_action_locals, __pyx_mstate_global->__pyx_n_u_neo_controller); if (unlikely(!gen)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("neo_controller.NeoController.plan_action.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_14neo_controller_13NeoController_11plan_action_2generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 6478, __pyx_L1_error)
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 6478, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6478, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6478, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6478, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6478, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6478, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_m);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_m, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_m, __pyx_mstate_global->__pyx_n_u_position); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 6478, __pyx_L1_error) }
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_t_4, __pyx_t_6, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_7) {
      __Pyx_XDECREF(__pyx_r);
      __Pyx_INCREF(Py_True);
      __pyx_r = Py_True;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __pyx_pf_14neo_controller_13NeoController_11plan_action_genexpr(((PyObject*)__pyx_cur_scope), __pyx_t_19); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    __pyx_t_19 = __Pyx_Generator_GetInlinedResult(__pyx_t_5); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_19);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6478, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
    if (__pyx_t_11) {
/* … */
      goto __pyx_L38;
    }

 6479:                 # We're probably within the radius of a mine we placed

+6480:                 print_explanation("We're probably within the radius of a mine we placed! Biasing faster/longer moves to be more likely to escape the mine.", self.current_timestep)

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6480, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6480, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_We_re_probably_within_the_radius, __pyx_t_6};
        __pyx_t_19 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6480, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
      }
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;

+6481:                 ship_cruise_speed_mode = SHIP_MAX_SPEED

      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_v_ship_cruise_speed_mode = __pyx_t_19;
      __pyx_t_19 = 0;

+6482:                 ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.75

      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_MAX_CRUISE_TIMESTEPS); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6482, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_7 = PyNumber_Multiply(__pyx_t_19, __pyx_mstate_global->__pyx_float_0_75); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6482, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __pyx_v_ship_cruise_timesteps_mode = __pyx_t_7;
      __pyx_t_7 = 0;

+6483:                 max_pre_maneuver_turn_timesteps = 10.0

      __pyx_v_max_pre_maneuver_turn_timesteps = 10.0;

 6484:             else:

+6485:                 max_pre_maneuver_turn_timesteps = 15.0

    /*else*/ {
      __pyx_v_max_pre_maneuver_turn_timesteps = 15.0;

 6486:                 #ship_cruise_speed_mode = NAN

 6487:                 #ship_cruise_timesteps_mode = NAN

 6488:                 #global total_abs_cruise_speed, total_cruise_timesteps, total_maneuvers_to_learn_from

 6489:                 #ship_cruise_speed_mode = total_abs_cruise_speed/total_maneuvers_to_learn_from

 6490:                 #ship_cruise_timesteps_mode = total_cruise_timesteps/total_maneuvers_to_learn_from

 6491:                 global abs_cruise_speeds, cruise_timesteps

+6492:                 ship_cruise_speed_mode = weighted_average(abs_cruise_speeds)

      __pyx_t_19 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6492, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_abs_cruise_speeds); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6492, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_19);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_19);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_19, __pyx_t_5};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6492, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __pyx_v_ship_cruise_speed_mode = __pyx_t_7;
      __pyx_t_7 = 0;

+6493:                 ship_cruise_timesteps_mode = weighted_average(cruise_timesteps)

      __pyx_t_6 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6493, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_cruise_timesteps); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6493, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_6);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_19};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6493, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __pyx_v_ship_cruise_timesteps_mode = __pyx_t_7;
      __pyx_t_7 = 0;
    }
    __pyx_L38:;

 6494:             '''

 6495:             if nearby_asteroid_count > 15:

 6496:                 # Many nearby asteroids

 6497:                 if nearby_asteroid_average_speed > 100:

 6498:                     # Fast asteroids

 6499:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.25

 6500:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.15

 6501:                 elif nearby_asteroid_average_speed > 50:

 6502:                     # Medium asteroids

 6503:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.18

 6504:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.1

 6505:                 else:

 6506:                     # Slow asteroids

 6507:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.0

 6508:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.0

 6509:             elif nearby_asteroid_count > 5:

 6510:                 # Some nearby asteroids

 6511:                 if nearby_asteroid_average_speed > 100:

 6512:                     # Fast asteroids

 6513:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.5

 6514:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.33

 6515:                 elif nearby_asteroid_average_speed > 50:

 6516:                     # Medium asteroids

 6517:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.5

 6518:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.28

 6519:                 else:

 6520:                     # Slow asteroids

 6521:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.5

 6522:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.25

 6523:             else:

 6524:                 # Few nearby asteroids

 6525:                 if nearby_asteroid_average_speed > 100:

 6526:                     # Fast asteroids

 6527:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.5

 6528:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.33

 6529:                 elif nearby_asteroid_average_speed > 50:

 6530:                     # Medium asteroids

 6531:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.37

 6532:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.33

 6533:                 else:

 6534:                     # Slow asteroids

 6535:                     ship_cruise_speed_mode = SHIP_MAX_SPEED*0.25

 6536:                     ship_cruise_timesteps_mode = MAX_CRUISE_TIMESTEPS*0.33

 6537:             '''

 6538:             # print(f"Nearby asteroids count is {nearby_asteroid_count}, average speed of asts is {nearby_asteroid_average_speed}, avg directional speed is {average_directional_speed}, so therefore I'm picking ship cruise timesteps mode to be {ship_cruise_timesteps_mode} and ship speed mode of {ship_cruise_speed_mode}")

+6539:             search_iterations_count = 0

    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
    __pyx_v_search_iterations_count = __pyx_mstate_global->__pyx_int_0;

+6540:             while (search_iterations_count < get_min_maneuver_per_timestep_search_iterations(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)) or self.performance_controller_check_whether_i_can_do_another_iteration()) and not search_iterations_count >= MAX_MANEUVER_PER_TIMESTEP_SEARCH_ITERATIONS:

    while (1) {
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_timestep_se); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_22 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_1))) {
        __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_1);
        assert(__pyx_t_22);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_22);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_22, __pyx_t_20};
        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6540, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_19))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_19);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_19, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_3};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6540, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __pyx_t_19 = PyObject_RichCompare(__pyx_v_search_iterations_count, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_19); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      if (!__pyx_t_12) {
      } else {
        goto __pyx_L45_next_and;
      }
      __pyx_t_7 = __pyx_cur_scope->__pyx_v_self;
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
        __pyx_t_19 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_performance_controller_check_whe, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6540, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
      }
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_19); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      if (__pyx_t_12) {
      } else {
        __pyx_t_11 = __pyx_t_12;
        goto __pyx_L44_bool_binop_done;
      }
      __pyx_L45_next_and:;
      __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_MAX_MANEUVER_PER_TIMESTEP_SEARCH); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __pyx_t_7 = PyObject_RichCompare(__pyx_v_search_iterations_count, __pyx_t_19, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6540, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_2 = (!__pyx_t_12);
      __pyx_t_11 = __pyx_t_2;
      __pyx_L44_bool_binop_done:;
      if (!__pyx_t_11) break;

+6541:                 self.performance_controller_start_iteration()

      __pyx_t_19 = __pyx_cur_scope->__pyx_v_self;
      __Pyx_INCREF(__pyx_t_19);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_19, NULL};
        __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_performance_controller_start_ite, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6541, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+6542:                 search_iterations_count += 1

      __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_v_search_iterations_count, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF_SET(__pyx_v_search_iterations_count, __pyx_t_7);
      __pyx_t_7 = 0;

+6543:                 if heuristic_maneuver:

      if (__pyx_v_heuristic_maneuver) {
/* … */
      }

+6544:                     random_ship_heading_angle = 0.0

        __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0);
        __Pyx_XDECREF_SET(__pyx_v_random_ship_heading_angle, __pyx_mstate_global->__pyx_float_0_0);

+6545:                     ship_accel_turn_rate, ship_cruise_speed, ship_cruise_turn_rate, ship_cruise_timesteps_float, thrust_direction = maneuver_heuristic_fis(imminent_asteroid_speed, imminent_asteroid_relative_heading, largest_gap_relative_heading, nearby_asteroid_average_speed, nearby_asteroid_count)

        __pyx_t_19 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_maneuver_heuristic_fis); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6545, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_3);
          assert(__pyx_t_19);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_19);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[6] = {__pyx_t_19, __pyx_v_imminent_asteroid_speed, __pyx_v_imminent_asteroid_relative_heading, __pyx_v_largest_gap_relative_heading, __pyx_v_nearby_asteroid_average_speed, __pyx_v_nearby_asteroid_count};
          __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_10, (6-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6545, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
        }
        if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
          PyObject* sequence = __pyx_t_7;
          Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
          if (unlikely(size != 5)) {
            if (size > 5) __Pyx_RaiseTooManyValuesError(5);
            else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
            __PYX_ERR(0, 6545, __pyx_L1_error)
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          if (likely(PyTuple_CheckExact(sequence))) {
            __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
            __Pyx_INCREF(__pyx_t_3);
            __pyx_t_19 = PyTuple_GET_ITEM(sequence, 1);
            __Pyx_INCREF(__pyx_t_19);
            __pyx_t_6 = PyTuple_GET_ITEM(sequence, 2);
            __Pyx_INCREF(__pyx_t_6);
            __pyx_t_5 = PyTuple_GET_ITEM(sequence, 3);
            __Pyx_INCREF(__pyx_t_5);
            __pyx_t_1 = PyTuple_GET_ITEM(sequence, 4);
            __Pyx_INCREF(__pyx_t_1);
          } else {
            __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 0);
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6545, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_3);
            __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 1);
            if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6545, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_19);
            __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 2);
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6545, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_6);
            __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 3);
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6545, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_5);
            __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 4);
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6545, __pyx_L1_error)
            __Pyx_XGOTREF(__pyx_t_1);
          }
          #else
          {
            Py_ssize_t i;
            PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_19,&__pyx_t_6,&__pyx_t_5,&__pyx_t_1};
            for (i=0; i < 5; i++) {
              PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 6545, __pyx_L1_error)
              __Pyx_GOTREF(item);
              *(temps[i]) = item;
            }
          }
          #endif
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        } else {
          Py_ssize_t index = -1;
          PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_19,&__pyx_t_6,&__pyx_t_5,&__pyx_t_1};
          __pyx_t_20 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6545, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_24 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_20);
          for (index=0; index < 5; index++) {
            PyObject* item = __pyx_t_24(__pyx_t_20); if (unlikely(!item)) goto __pyx_L48_unpacking_failed;
            __Pyx_GOTREF(item);
            *(temps[index]) = item;
          }
          if (__Pyx_IternextUnpackEndCheck(__pyx_t_24(__pyx_t_20), 5) < 0) __PYX_ERR(0, 6545, __pyx_L1_error)
          __pyx_t_24 = NULL;
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          goto __pyx_L49_unpacking_done;
          __pyx_L48_unpacking_failed:;
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __pyx_t_24 = NULL;
          if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
          __PYX_ERR(0, 6545, __pyx_L1_error)
          __pyx_L49_unpacking_done:;
        }
        __Pyx_XDECREF_SET(__pyx_v_ship_accel_turn_rate, __pyx_t_3);
        __pyx_t_3 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_speed, __pyx_t_19);
        __pyx_t_19 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_turn_rate, __pyx_t_6);
        __pyx_t_6 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps_float, __pyx_t_5);
        __pyx_t_5 = 0;
        __Pyx_XDECREF_SET(__pyx_v_thrust_direction, __pyx_t_1);
        __pyx_t_1 = 0;

 6546:                     # print(ship_accel_turn_rate, ship_cruise_speed, ship_cruise_turn_rate, ship_cruise_timesteps, thrust_direction)

+6547:                     ship_cruise_timesteps = round(ship_cruise_timesteps_float)

        __pyx_t_1 = NULL;
        __Pyx_INCREF(__pyx_builtin_round);
        __pyx_t_5 = __pyx_builtin_round; 
        __pyx_t_10 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_ship_cruise_timesteps_float};
          __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6547, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
        }
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps, __pyx_t_7);
        __pyx_t_7 = 0;

+6548:                     if thrust_direction < -GRAIN:

        __pyx_t_7 = PyFloat_FromDouble((-__pyx_v_14neo_controller_GRAIN)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6548, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_5 = PyObject_RichCompare(__pyx_v_thrust_direction, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6548, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6548, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (__pyx_t_11) {
/* … */
          goto __pyx_L50;
        }

+6549:                         ship_cruise_speed = -ship_cruise_speed

          __pyx_t_5 = PyNumber_Negative(__pyx_v_ship_cruise_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6549, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF_SET(__pyx_v_ship_cruise_speed, __pyx_t_5);
          __pyx_t_5 = 0;

+6550:                     elif thrust_direction < GRAIN:

        __pyx_t_5 = PyFloat_FromDouble(__pyx_v_14neo_controller_GRAIN); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_7 = PyObject_RichCompare(__pyx_v_thrust_direction, __pyx_t_5, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6550, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6550, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (__pyx_t_11) {
/* … */
        }
        __pyx_L50:;

 6551:                         # The FIS couldn't decide which way to thrust, so we'll just skip the heuristic maneuver altogether

+6552:                         heuristic_maneuver = False

          __pyx_v_heuristic_maneuver = 0;

 6553:                 # The reason this isn't an if-else statement is that even if we wanted to do a heuristic maneuver, the heuristic output could be bad and so we skip the heuristic maneuver altogether

+6554:                 if not heuristic_maneuver:

      __pyx_t_11 = (!__pyx_v_heuristic_maneuver);
      if (__pyx_t_11) {
/* … */
      }

+6555:                     random_ship_heading_angle = random.triangular(-DEGREES_TURNED_PER_TIMESTEP*max_pre_maneuver_turn_timesteps, DEGREES_TURNED_PER_TIMESTEP*max_pre_maneuver_turn_timesteps, 0)

        __pyx_t_5 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_triangular); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DEGREES_TURNED_PER_TIMESTEP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_19 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = PyFloat_FromDouble(__pyx_v_max_pre_maneuver_turn_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = PyNumber_Multiply(__pyx_t_19, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DEGREES_TURNED_PER_TIMESTEP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_19 = PyFloat_FromDouble(__pyx_v_max_pre_maneuver_turn_timesteps); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_19);
        __pyx_t_20 = PyNumber_Multiply(__pyx_t_1, __pyx_t_19); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6555, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_6))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
          assert(__pyx_t_5);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_20, __pyx_mstate_global->__pyx_int_0};
          __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6555, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
        }
        __Pyx_XDECREF_SET(__pyx_v_random_ship_heading_angle, __pyx_t_7);
        __pyx_t_7 = 0;

+6556:                     ship_accel_turn_rate = random.triangular(0, SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE)*(2.0*float(random.getrandbits(1)) - 1.0)

        __pyx_t_6 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_triangular); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
          assert(__pyx_t_6);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_6);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_20, __pyx_t_5};
          __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6556, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
        }
        __pyx_t_5 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_getrandbits); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_6))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
          assert(__pyx_t_5);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_1};
          __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6556, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __pyx_t_25 = __Pyx_PyObject_AsDouble(__pyx_t_3); if (unlikely(__pyx_t_25 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyFloat_FromDouble(((2.0 * __pyx_t_25) - 1.0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_6 = PyNumber_Multiply(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6556, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_accel_turn_rate, __pyx_t_6);
        __pyx_t_6 = 0;

 6557:                     # random_ship_cruise_speed = random.uniform(-ship_max_speed, ship_max_speed)

+6558:                     if isnan(ship_cruise_speed_mode):

        __pyx_t_26 = __Pyx_PyFloat_AsDouble(__pyx_v_ship_cruise_speed_mode); if (unlikely((__pyx_t_26 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 6558, __pyx_L1_error)
        __pyx_t_11 = isnan(__pyx_t_26);
        if (__pyx_t_11) {
/* … */
          goto __pyx_L52;
        }

+6559:                         ship_cruise_speed = random.uniform(-SHIP_MAX_SPEED, SHIP_MAX_SPEED)

          __pyx_t_3 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6559, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_uniform); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6559, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6559, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_20 = PyNumber_Negative(__pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6559, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6559, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_3);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_3);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_20, __pyx_t_7};
            __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6559, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __Pyx_XDECREF_SET(__pyx_v_ship_cruise_speed, __pyx_t_6);
          __pyx_t_6 = 0;

 6560:                     else:

+6561:                         ship_cruise_speed = random.triangular(0, SHIP_MAX_SPEED, ship_cruise_speed_mode)*(2.0*float(random.getrandbits(1)) - 1.0)  # random.triangular(0, SHIP_MAX_SPEED, SHIP_MAX_SPEED)*(2.0*float(random.getrandbits(1)) - 1.0)

        /*else*/ {
          __pyx_t_5 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_triangular); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_SPEED); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_20))) {
            __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_20);
            assert(__pyx_t_5);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_20);
            __Pyx_INCREF(__pyx_t_5);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_20, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_v_ship_cruise_speed_mode};
            __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_20, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6561, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_6);
          }
          __pyx_t_7 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_getrandbits); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_3))) {
            __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
            assert(__pyx_t_7);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
            __Pyx_INCREF(__pyx_t_7);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_1};
            __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6561, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
          }
          __pyx_t_25 = __Pyx_PyObject_AsDouble(__pyx_t_20); if (unlikely(__pyx_t_25 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __pyx_t_20 = PyFloat_FromDouble(((2.0 * __pyx_t_25) - 1.0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
          __pyx_t_3 = PyNumber_Multiply(__pyx_t_6, __pyx_t_20); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6561, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __Pyx_XDECREF_SET(__pyx_v_ship_cruise_speed, __pyx_t_3);
          __pyx_t_3 = 0;
        }
        __pyx_L52:;

+6562:                     ship_cruise_turn_rate = random.triangular(0, SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE)*(2.0*float(random.getrandbits(1)) - 1.0)  # random.uniform(-SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE)

        __pyx_t_20 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_triangular); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_7))) {
          __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7);
          assert(__pyx_t_20);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
          __Pyx_INCREF(__pyx_t_20);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_20, __pyx_mstate_global->__pyx_int_0, __pyx_t_6, __pyx_t_5};
          __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6562, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __pyx_t_5 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_getrandbits); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_20))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_20);
          assert(__pyx_t_5);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_20);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_20, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_1};
          __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_20, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6562, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
        }
        __pyx_t_25 = __Pyx_PyObject_AsDouble(__pyx_t_7); if (unlikely(__pyx_t_25 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __pyx_t_7 = PyFloat_FromDouble(((2.0 * __pyx_t_25) - 1.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_20 = PyNumber_Multiply(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6562, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF_SET(__pyx_v_ship_cruise_turn_rate, __pyx_t_20);
        __pyx_t_20 = 0;

 6563:                     # TODO: For denser asteroid fields, decrease the max cruise seconds to encourage shorter maneuvers!

 6564:                     # ship_cruise_timesteps = random.randint(1, round(max_cruise_seconds*FPS))

+6565:                     if isnan(ship_cruise_timesteps_mode):

        __pyx_t_26 = __Pyx_PyFloat_AsDouble(__pyx_v_ship_cruise_timesteps_mode); if (unlikely((__pyx_t_26 == (long double)-1) && PyErr_Occurred())) __PYX_ERR(0, 6565, __pyx_L1_error)
        __pyx_t_11 = isnan(__pyx_t_26);
        if (__pyx_t_11) {
/* … */
          goto __pyx_L53;
        }

+6566:                         ship_cruise_timesteps = random.randint(0, round(MAX_CRUISE_TIMESTEPS))

          __pyx_t_7 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6566, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_randint); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6566, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_6 = NULL;
          __Pyx_INCREF(__pyx_builtin_round);
          __pyx_t_19 = __pyx_builtin_round; 
          __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_MAX_CRUISE_TIMESTEPS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6566, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_10 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1};
            __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6566, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_7);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_7);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_3};
            __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6566, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
          }
          __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps, __pyx_t_20);
          __pyx_t_20 = 0;

 6567:                     else:

+6568:                         ship_cruise_timesteps = floor(random.triangular(0.0, MAX_CRUISE_TIMESTEPS, ship_cruise_timesteps_mode))

        /*else*/ {
          __pyx_t_5 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_floor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6568, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_19 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6568, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_triangular); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6568, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_MAX_CRUISE_TIMESTEPS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6568, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_6))) {
            __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_6);
            assert(__pyx_t_19);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
            __Pyx_INCREF(__pyx_t_19);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[4] = {__pyx_t_19, __pyx_mstate_global->__pyx_float_0_0, __pyx_t_1, __pyx_v_ship_cruise_timesteps_mode};
            __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
            if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6568, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
          }
          __pyx_t_10 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_3))) {
            __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
            assert(__pyx_t_5);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
            __Pyx_INCREF(__pyx_t_5);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
            __pyx_t_10 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7};
            __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6568, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
          }
          __Pyx_XDECREF_SET(__pyx_v_ship_cruise_timesteps, __pyx_t_20);
          __pyx_t_20 = 0;
        }
        __pyx_L53:;

 6569: 

 6570:                     '''

 6571:                     random_ship_heading_angle = random.triangular(-6.0*10.0, 6.0*10.0, 0)

 6572:                     ship_accel_turn_rate = random.triangular(0, SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE)*(2.0*float(random.getrandbits(1)) - 1.0)

 6573:                     #random_ship_cruise_speed = random.uniform(-ship_max_speed, ship_max_speed)

 6574:                     ship_cruise_speed = random.uniform(-SHIP_MAX_SPEED, SHIP_MAX_SPEED)#random.triangular(0, SHIP_MAX_SPEED, SHIP_MAX_SPEED)*(2.0*float(random.getrandbits(1)) - 1.0)

 6575:                     ship_cruise_turn_rate = random.triangular(0, SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE)*(2.0*float(random.getrandbits(1)) - 1.0)#random.uniform(-SHIP_MAX_TURN_RATE, SHIP_MAX_TURN_RATE)

 6576:                     # TODO: For denser asteroid fields, decrease the max cruise seconds to encourage shorter maneuvers!

 6577:                     #ship_cruise_timesteps = random.randint(1, round(max_cruise_seconds*FPS))

 6578:                     ship_cruise_timesteps = floor(random.triangular(0.0, max_cruise_seconds*FPS, 0.0))

 6579:                     '''

 6580: 

 6581:                 # First do a dummy simulation just to go through the motion, so we have the list of moves

 6582:                 #print(f"\nDoing the move shenanigans")

+6583:                 preview_move_sequence = get_ship_maneuver_move_sequence(random_ship_heading_angle, ship_cruise_speed, ship_accel_turn_rate, ship_cruise_timesteps, ship_cruise_turn_rate, self.game_state_to_base_planning['ship_state'].speed)

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_get_ship_maneuver_move_sequence_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6583, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(!__pyx_v_random_ship_heading_angle)) { __Pyx_RaiseUnboundLocalError("random_ship_heading_angle"); __PYX_ERR(0, 6583, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_cruise_speed)) { __Pyx_RaiseUnboundLocalError("ship_cruise_speed"); __PYX_ERR(0, 6583, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_accel_turn_rate)) { __Pyx_RaiseUnboundLocalError("ship_accel_turn_rate"); __PYX_ERR(0, 6583, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_cruise_timesteps)) { __Pyx_RaiseUnboundLocalError("ship_cruise_timesteps"); __PYX_ERR(0, 6583, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_cruise_turn_rate)) { __Pyx_RaiseUnboundLocalError("ship_cruise_turn_rate"); __PYX_ERR(0, 6583, __pyx_L1_error) }
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6583, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6583, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_speed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6583, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[7] = {__pyx_t_3, __pyx_v_random_ship_heading_angle, __pyx_v_ship_cruise_speed, __pyx_v_ship_accel_turn_rate, __pyx_v_ship_cruise_timesteps, __pyx_v_ship_cruise_turn_rate, __pyx_t_5};
        __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_10, (7-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6583, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
      }
      __Pyx_XDECREF_SET(__pyx_v_preview_move_sequence, __pyx_t_20);
      __pyx_t_20 = 0;

+6584:                 maneuver_sim = Matrix(game_state=self.game_state_to_base_planning['game_state'],

      __pyx_t_7 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Matrix); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6584, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6585:                                       ship_state=self.game_state_to_base_planning['ship_state'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6585, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6585, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6586:                                       initial_timestep=self.game_state_to_base_planning['timestep'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6586, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_19 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 6586, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_19);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6587:                                       respawn_timer=self.game_state_to_base_planning['ship_respawn_timer'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6587, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_22 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 6587, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_22);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6588:                                       asteroids_pending_death=self.game_state_to_base_planning['asteroids_pending_death'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6588, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_23 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 6588, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_23);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6589:                                       forecasted_asteroid_splits=self.game_state_to_base_planning['forecasted_asteroid_splits'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6589, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6589, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6590:                                       last_timestep_fired=self.game_state_to_base_planning['last_timestep_fired'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6590, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6590, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6591:                                       last_timestep_mined=self.game_state_to_base_planning['last_timestep_mined'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6591, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_16 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6591, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_16);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6592:                                       mine_positions_placed=self.game_state_to_base_planning['mine_positions_placed'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6592, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6592, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 6593:                                       halt_shooting=False,

+6594:                                       fire_first_timestep=self.game_state_to_base_planning['fire_next_timestep_flag'],

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6594, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6594, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6595:                                       verify_first_shot=True if len(self.sims_this_planning_period) == 0 and other_ships_exist else False,

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6595, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_13 = PyObject_Length(__pyx_t_8); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6595, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_2 = (__pyx_t_13 == 0);
      if (__pyx_t_2) {
      } else {
        __pyx_t_11 = __pyx_t_2;
        goto __pyx_L54_bool_binop_done;
      }
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_other_ships_exist); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6595, __pyx_L1_error)
      __pyx_t_11 = __pyx_t_2;
      __pyx_L54_bool_binop_done:;
      if (__pyx_t_11) {
        __Pyx_INCREF(Py_True);
        __pyx_t_3 = Py_True;
      } else {
        __Pyx_INCREF(Py_False);
        __pyx_t_3 = Py_False;
      }

 6596:                                       verify_maneuver_shots=False,

+6597:                                       game_state_plotter=self.game_state_plotter)

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6597, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_7);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 14 : 0)] = {__pyx_t_7, NULL};
        __pyx_t_18 = __Pyx_MakeVectorcallBuilderKwds(14); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 6584, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_18);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state, __pyx_t_6, __pyx_t_18, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_1, __pyx_t_18, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_initial_timestep, __pyx_t_19, __pyx_t_18, __pyx_callargs+1, 2) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_respawn_timer, __pyx_t_22, __pyx_t_18, __pyx_callargs+1, 3) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_23, __pyx_t_18, __pyx_callargs+1, 4) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_9, __pyx_t_18, __pyx_callargs+1, 5) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_15, __pyx_t_18, __pyx_callargs+1, 6) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_16, __pyx_t_18, __pyx_callargs+1, 7) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_17, __pyx_t_18, __pyx_callargs+1, 8) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_halt_shooting, Py_False, __pyx_t_18, __pyx_callargs+1, 9) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fire_first_timestep, __pyx_t_4, __pyx_t_18, __pyx_callargs+1, 10) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_first_shot, __pyx_t_3, __pyx_t_18, __pyx_callargs+1, 11) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_verify_maneuver_shots, Py_False, __pyx_t_18, __pyx_callargs+1, 12) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_game_state_plotter, __pyx_t_8, __pyx_t_18, __pyx_callargs+1, 13) < 0) __PYX_ERR(0, 6584, __pyx_L1_error)
        __pyx_t_20 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_5, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_18);
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6584, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
      }
      __Pyx_XDECREF_SET(__pyx_v_maneuver_sim, __pyx_t_20);
      __pyx_t_20 = 0;

 6598:                 # While evaluating, the simulation is advancing, and if it crashes, then it'll evaluate to false and stop the sim.

 6599:                 #print(preview_move_sequence)

 6600:                 #if maneuver_sim.get_sim_id() == 333:

 6601:                 #    print('\ncalling sim maneuver in plan maneuver')

+6602:                 if maneuver_sim.simulate_maneuver(preview_move_sequence, True, True):

      __pyx_t_5 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_v_preview_move_sequence, Py_True, Py_True};
        __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_simulate_maneuver, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6602, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
      }
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6602, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      if (__pyx_t_11) {
        goto __pyx_L56;
      }

 6603:                     # The ship went through all the steps without colliding

 6604:                     #pre_fitness = maneuver_sim.get_fitness()

 6605:                     #pre_fitness_breakdown = maneuver_sim.get_fitness_breakdown()

 6606:                     #if maneuver_sim.get_sim_id() == 333:

 6607:                     #    print(f"After sim maneuver in plan maneuver, The ship went through all the steps without colliding and lasted {len(maneuver_sim.get_state_sequence())}")

 6608:                     # maneuver_complete_without_crash = True

 6609:                     pass

 6610:                 else:

 6611:                     # The ship crashed somewhere before reaching the final resting spot

 6612:                     #pre_fitness = maneuver_sim.get_fitness()

 6613:                     #pre_fitness_breakdown = maneuver_sim.get_fitness_breakdown()

 6614:                     #if maneuver_sim.get_sim_id() == 333:

 6615:                     #    print(f"After sim maneuver in plan maneuver, The ship crashed somewhere before reaching the final resting spot and only lasted {len(maneuver_sim.get_state_sequence())}")

 6616:                     # maneuver_complete_without_crash = False

+6617:                     pass

      /*else*/ {
      }
      __pyx_L56:;

 6618:                 # print(f"Maneuver completed without crash: {maneuver_complete_without_crash}")

+6619:                 maneuver_fitness = maneuver_sim.get_fitness()

      __pyx_t_5 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6619, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
      }
      __Pyx_XDECREF_SET(__pyx_v_maneuver_fitness, __pyx_t_20);
      __pyx_t_20 = 0;

 6620:                 #print(f"Maneuver fitness: {maneuver_fitness}, maneuver tuple: {random_ship_heading_angle=} {ship_cruise_speed=} {ship_accel_turn_rate=} {ship_cruise_timesteps=} {ship_cruise_turn_rate=}")

+6621:                 maneuver_fitness_breakdown = maneuver_sim.get_fitness_breakdown()

      __pyx_t_5 = __pyx_v_maneuver_sim;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_fitness_breakdown, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6621, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_20);
      }
      __Pyx_XDECREF_SET(__pyx_v_maneuver_fitness_breakdown, __pyx_t_20);
      __pyx_t_20 = 0;

 6622:                 #post_fitness = maneuver_sim.get_fitness()

 6623:                 #print(f"{pre_fitness=} {pre_fitness_breakdown=}, {maneuver_fitness=} {maneuver_fitness_breakdown=}, {post_fitness=}")

+6624:                 if len(self.sims_this_planning_period) == 0:

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6624, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_13 = PyObject_Length(__pyx_t_20); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6624, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_11 = (__pyx_t_13 == 0);
      if (__pyx_t_11) {
/* … */
      }

+6625:                     if maneuver_sim.get_cancel_firing_first_timestep():

        __pyx_t_5 = __pyx_v_maneuver_sim;
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_10 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
          __pyx_t_20 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_get_cancel_firing_first_timestep, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6625, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_20);
        }
        __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6625, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
        if (__pyx_t_11) {
/* … */
        }

 6626:                         # The plan was to first at the first timestep this planning period. However, due to non-determinism caused by the existence of another ship, this shot would actually miss. We checked and caught this, so we're going to just nix the idea of shooting on the first timestep.

+6627:                         assert self.game_state_to_base_planning['fire_next_timestep_flag']  # REMOVE_FOR_COMPETITION

          #ifndef CYTHON_WITHOUT_ASSERTIONS
          if (unlikely(__pyx_assertions_enabled())) {
            __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6627, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
            __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6627, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6627, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_11)) {
              __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
              __PYX_ERR(0, 6627, __pyx_L1_error)
            }
          }
          #else
          if ((1)); else __PYX_ERR(0, 6627, __pyx_L1_error)
          #endif

+6628:                         self.game_state_to_base_planning['fire_next_timestep_flag'] = False

          __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6628, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0))) __PYX_ERR(0, 6628, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 6629:                 '''

 6630:                 global heuristic_fis_iterations

 6631:                 global heuristic_fis_total_fitness

 6632:                 global random_search_iterations

 6633:                 global random_search_total_fitness

 6634:                 if heuristic_maneuver:

 6635:                     heuristic_fis_iterations += 1

 6636:                     heuristic_fis_total_fitness += maneuver_fitness

 6637:                 else:

 6638:                     random_search_iterations += 1

 6639:                     random_search_total_fitness += maneuver_fitness

 6640:                 '''

 6641: 

+6642:                 self.sims_this_planning_period.append({

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6642, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
/* … */
      __pyx_t_21 = __Pyx_PyObject_Append(__pyx_t_5, __pyx_t_20); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 6642, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

+6643:                     'sim': maneuver_sim,

      __pyx_t_20 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6643, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      if (PyDict_SetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_sim, __pyx_v_maneuver_sim) < 0) __PYX_ERR(0, 6643, __pyx_L1_error)

+6644:                     'fitness': maneuver_fitness,

      if (PyDict_SetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_fitness, __pyx_v_maneuver_fitness) < 0) __PYX_ERR(0, 6643, __pyx_L1_error)

+6645:                     'fitness_breakdown': maneuver_fitness_breakdown,

      if (PyDict_SetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_fitness_breakdown, __pyx_v_maneuver_fitness_breakdown) < 0) __PYX_ERR(0, 6643, __pyx_L1_error)

+6646:                     'action_type': 'heuristic_maneuver' if heuristic_maneuver else 'random_maneuver',

      if (__pyx_v_heuristic_maneuver) {
        __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_heuristic_maneuver);
        __pyx_t_18 = __pyx_mstate_global->__pyx_n_u_heuristic_maneuver;
      } else {
        __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_random_maneuver);
        __pyx_t_18 = __pyx_mstate_global->__pyx_n_u_random_maneuver;
      }
      if (PyDict_SetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_action_type, __pyx_t_18) < 0) __PYX_ERR(0, 6643, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

+6647:                     'state_type': state_type,

      if (PyDict_SetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_state_type, __pyx_v_state_type) < 0) __PYX_ERR(0, 6643, __pyx_L1_error)

+6648:                     'maneuver_tuple': (random_ship_heading_angle, ship_cruise_speed, ship_accel_turn_rate, ship_cruise_timesteps, ship_cruise_turn_rate)

      if (unlikely(!__pyx_v_random_ship_heading_angle)) { __Pyx_RaiseUnboundLocalError("random_ship_heading_angle"); __PYX_ERR(0, 6648, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_cruise_speed)) { __Pyx_RaiseUnboundLocalError("ship_cruise_speed"); __PYX_ERR(0, 6648, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_accel_turn_rate)) { __Pyx_RaiseUnboundLocalError("ship_accel_turn_rate"); __PYX_ERR(0, 6648, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_cruise_timesteps)) { __Pyx_RaiseUnboundLocalError("ship_cruise_timesteps"); __PYX_ERR(0, 6648, __pyx_L1_error) }
      if (unlikely(!__pyx_v_ship_cruise_turn_rate)) { __Pyx_RaiseUnboundLocalError("ship_cruise_turn_rate"); __PYX_ERR(0, 6648, __pyx_L1_error) }
      __pyx_t_18 = PyTuple_New(5); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 6648, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
      __Pyx_INCREF(__pyx_v_random_ship_heading_angle);
      __Pyx_GIVEREF(__pyx_v_random_ship_heading_angle);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_v_random_ship_heading_angle) != (0)) __PYX_ERR(0, 6648, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_cruise_speed);
      __Pyx_GIVEREF(__pyx_v_ship_cruise_speed);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_v_ship_cruise_speed) != (0)) __PYX_ERR(0, 6648, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_accel_turn_rate);
      __Pyx_GIVEREF(__pyx_v_ship_accel_turn_rate);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 2, __pyx_v_ship_accel_turn_rate) != (0)) __PYX_ERR(0, 6648, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_cruise_timesteps);
      __Pyx_GIVEREF(__pyx_v_ship_cruise_timesteps);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 3, __pyx_v_ship_cruise_timesteps) != (0)) __PYX_ERR(0, 6648, __pyx_L1_error);
      __Pyx_INCREF(__pyx_v_ship_cruise_turn_rate);
      __Pyx_GIVEREF(__pyx_v_ship_cruise_turn_rate);
      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_18, 4, __pyx_v_ship_cruise_turn_rate) != (0)) __PYX_ERR(0, 6648, __pyx_L1_error);
      if (PyDict_SetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_maneuver_tuple, __pyx_t_18) < 0) __PYX_ERR(0, 6643, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

 6649:                 })

 6650:                 # if heuristic_maneuver:

 6651:                 #    debug_print(f"Heuristic maneuver got fitness of {maneuver_fitness}")

 6652:                 # debug_print(f"Planning random maneuver, and got fitness {maneuver_fitness}")

+6653:                 if maneuver_fitness > self.best_fitness_this_planning_period:

      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 6653, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_20);
      __pyx_t_5 = PyObject_RichCompare(__pyx_v_maneuver_fitness, __pyx_t_20, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6653, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
      __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 6653, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_11) {
/* … */
      }

+6654:                     self.second_best_fitness_this_planning_period = self.best_fitness_this_planning_period

        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6654, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_5) < 0) __PYX_ERR(0, 6654, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6655:                     self.second_best_fitness_this_planning_period_index = self.best_fitness_this_planning_period_index

        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6655, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_5) < 0) __PYX_ERR(0, 6655, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 6656: 

+6657:                     self.best_fitness_this_planning_period = maneuver_fitness

        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_v_maneuver_fitness) < 0) __PYX_ERR(0, 6657, __pyx_L1_error)

+6658:                     self.best_fitness_this_planning_period_index = len(self.sims_this_planning_period) - 1

        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_13 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6658, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = PyLong_FromSsize_t((__pyx_t_13 - 1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6658, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (__Pyx_PyObject_SetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_5) < 0) __PYX_ERR(0, 6658, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6659:                 if heuristic_maneuver:

      if (__pyx_v_heuristic_maneuver) {
/* … */
      }
    }
  }
  __pyx_L3:;

 6660:                     # Make sure we don't do any more than one heuristic maneuver!

+6661:                     heuristic_maneuver = False

        __pyx_v_heuristic_maneuver = 0;

 6662: 

+6663:     def actions(self, ship_state_dict: dict[str, Any], game_state_dict: dict[str, Any] | immutabledict[str, Any]) -> tuple[float, float, bool, bool]:

/* Python wrapper */
static PyObject *__pyx_pw_14neo_controller_13NeoController_27actions(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_14neo_controller_13NeoController_27actions = {"actions", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_14neo_controller_13NeoController_27actions, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_14neo_controller_13NeoController_27actions(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_ship_state_dict = 0;
  PyObject *__pyx_v_game_state_dict = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("actions (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_ship_state_dict,&__pyx_mstate_global->__pyx_n_u_game_state_dict,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 6663, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 6663, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 6663, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 6663, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "actions", 0) < 0) __PYX_ERR(0, 6663, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("actions", 1, 3, 3, i); __PYX_ERR(0, 6663, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 6663, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 6663, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 6663, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_ship_state_dict = ((PyObject*)values[1]);
    __pyx_v_game_state_dict = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("actions", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 6663, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("neo_controller.NeoController.actions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ship_state_dict), (&PyDict_Type), 0, "ship_state_dict", 2))) __PYX_ERR(0, 6663, __pyx_L1_error)
  __pyx_r = __pyx_pf_14neo_controller_13NeoController_26actions(__pyx_self, __pyx_v_self, __pyx_v_ship_state_dict, __pyx_v_game_state_dict);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_14neo_controller_13NeoController_26actions(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_ship_state_dict, PyObject *__pyx_v_game_state_dict) {
  int __pyx_v_recovering_from_crash;
  PyObject *__pyx_v_ship_state = NULL;
  PyObject *__pyx_v_game_state = NULL;
  int __pyx_v_timestep_mismatch;
  PyObject *__pyx_v_action_queue_desync = NULL;
  PyObject *__pyx_v_planning_base_state_outdated = NULL;
  int __pyx_v_iterations_boost;
  int __pyx_v_unexpected_death;
  int __pyx_v_unexpected_survival;
  CYTHON_UNUSED PyObject *__pyx_v__ = NULL;
  PyObject *__pyx_v_success = NULL;
  PyObject *__pyx_v_thrust = NULL;
  PyObject *__pyx_v_turn_rate = NULL;
  PyObject *__pyx_v_fire = NULL;
  PyObject *__pyx_v_drop_mine = NULL;
  PyObject *__pyx_v_flattened_asteroids_pending_death = NULL;
  PyObject *__pyx_v_state_dump_dict = NULL;
  PyObject *__pyx_v_simulated_gamestate = NULL;
  PyObject *__pyx_9genexpr56__pyx_v_ast_list = NULL;
  PyObject *__pyx_9genexpr56__pyx_v_ast = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state_dict, __pyx_mstate_global->__pyx_kp_u_dict_str_Any) < 0) __PYX_ERR(0, 6663, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state_dict, __pyx_mstate_global->__pyx_kp_u_dict_str_Any_immutabledict_str_A) < 0) __PYX_ERR(0, 6663, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_tuple_float_float_bool_bool) < 0) __PYX_ERR(0, 6663, __pyx_L1_error)
  __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_14neo_controller_13NeoController_27actions, 0, __pyx_mstate_global->__pyx_n_u_NeoController_actions, NULL, __pyx_mstate_global->__pyx_n_u_neo_controller, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[205])); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 6663, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_11, __pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_actions, __pyx_t_11) < 0) __PYX_ERR(0, 6663, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

 6664:         # Method processed each time step by this controller.

 6665: 

+6666:         if RESEED_RNG:

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_RESEED_RNG); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6666, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+6667:             random.seed()

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6667, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_seed); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6667, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6667, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6668:         self.current_timestep += 1

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_t_5) < 0) __PYX_ERR(0, 6668, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6669:         recovering_from_crash = False

  __pyx_v_recovering_from_crash = 0;

 6670:         #print(f"Calling Neo's actions() on timestep {game_state_dict['sim_frame']}, and Neo thinks it's timestep {self.current_timestep}")

 6671:         #print(self.action_queue)

+6672:         ship_state = create_ship_from_dict(cast(ShipDict, ship_state_dict))

  __pyx_t_1 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_create_ship_from_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ShipDict); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
    assert(__pyx_t_7);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_7);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_9, __pyx_v_ship_state_dict};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6672, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_1);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6672, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_v_ship_state = __pyx_t_5;
  __pyx_t_5 = 0;

+6673:         game_state = create_game_state_from_dict(cast(GameStateDict, game_state_dict))

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_create_game_state_from_dict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_GameStateDict); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_9))) {
    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9);
    assert(__pyx_t_8);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_7, __pyx_v_game_state_dict};
    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6673, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_6 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_6 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_1};
    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6673, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_v_game_state = __pyx_t_5;
  __pyx_t_5 = 0;

 6674: 

+6675:         if CLEAN_UP_STATE_FOR_SUBSEQUENT_SCENARIO_RUNS or STATE_CONSISTENCY_CHECK_AND_RECOVERY:

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_CLEAN_UP_STATE_FOR_SUBSEQUENT_SC); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6675, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6675, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (!__pyx_t_10) {
  } else {
    __pyx_t_2 = __pyx_t_10;
    goto __pyx_L5_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_STATE_CONSISTENCY_CHECK_AND_RECO); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6675, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6675, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __pyx_t_10;
  __pyx_L5_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

+6676:             timestep_mismatch: bool = not game_state.sim_frame == self.current_timestep

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_sim_frame); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6676, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6676, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6676, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6676, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_timestep_mismatch = (!__pyx_t_2);

 6677:             # Amid running the scenario, the action queue is desynced with our timestep. This may be caused by an exception that was raised in Neo which was caught by Kessler, so the actions for this timestep were never consumed.

+6678:             action_queue_desync: bool = len(self.action_queue) > 0 and self.action_queue[0][0] != self.current_timestep

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_11 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6678, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_2 = (__pyx_t_11 > 0);
    if (__pyx_t_2) {
    } else {
      __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6678, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = __pyx_t_4;
      __pyx_t_4 = 0;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6678, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6678, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = __pyx_t_3;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_L7_bool_binop_done:;
    __pyx_v_action_queue_desync = __pyx_t_1;
    __pyx_t_1 = 0;

+6679:             planning_base_state_outdated: bool = self.game_state_to_base_planning is not None and self.game_state_to_base_planning['timestep'] < self.current_timestep

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6679, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = (__pyx_t_3 != Py_None);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_2) {
    } else {
      __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6679, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __pyx_t_3;
      __pyx_t_3 = 0;
      goto __pyx_L9_bool_binop_done;
    }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6679, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6679, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6679, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6679, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_1 = __pyx_t_4;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_L9_bool_binop_done:;
    __pyx_v_planning_base_state_outdated = __pyx_t_1;
    __pyx_t_1 = 0;

+6680:             if timestep_mismatch or (STATE_CONSISTENCY_CHECK_AND_RECOVERY and (action_queue_desync or planning_base_state_outdated)):

    if (!__pyx_v_timestep_mismatch) {
    } else {
      __pyx_t_2 = __pyx_v_timestep_mismatch;
      goto __pyx_L12_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_STATE_CONSISTENCY_CHECK_AND_RECO); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6680, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6680, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_10) {
    } else {
      __pyx_t_2 = __pyx_t_10;
      goto __pyx_L12_bool_binop_done;
    }
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_action_queue_desync); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6680, __pyx_L1_error)
    if (!__pyx_t_10) {
    } else {
      __pyx_t_2 = __pyx_t_10;
      goto __pyx_L12_bool_binop_done;
    }
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_planning_base_state_outdated); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6680, __pyx_L1_error)
    __pyx_t_2 = __pyx_t_10;
    __pyx_L12_bool_binop_done:;
    if (__pyx_t_2) {
/* … */
    }

+6681:                 if timestep_mismatch and not (action_queue_desync or planning_base_state_outdated):

      if (__pyx_v_timestep_mismatch) {
      } else {
        __pyx_t_2 = __pyx_v_timestep_mismatch;
        goto __pyx_L17_bool_binop_done;
      }
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_action_queue_desync); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6681, __pyx_L1_error)
      if (!__pyx_t_12) {
      } else {
        __pyx_t_10 = __pyx_t_12;
        goto __pyx_L19_bool_binop_done;
      }
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_planning_base_state_outdated); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6681, __pyx_L1_error)
      __pyx_t_10 = __pyx_t_12;
      __pyx_L19_bool_binop_done:;
      __pyx_t_12 = (!__pyx_t_10);
      __pyx_t_2 = __pyx_t_12;
      __pyx_L17_bool_binop_done:;
      if (__pyx_t_2) {
/* … */
        goto __pyx_L16;
      }

+6682:                     debug_print("This was not a fresh run of the controller! I'll try cleaning up the previous run and reset the state.")

        __pyx_t_4 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6682, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
          assert(__pyx_t_4);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_This_was_not_a_fresh_run_of_the};
          __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6682, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6683:                 elif timestep_mismatch:

      if (__pyx_v_timestep_mismatch) {
/* … */
      }
      __pyx_L16:;

+6684:                     debug_print(f"Neo didn't start from time 0. Was there a controller exception? Setting timestep to match the passed-in game state's nonzero starting timestep of: {game_state.sim_frame}")

        __pyx_t_3 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6684, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_sim_frame); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6684, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6684, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Neo_didn_t_start_from_time_0_Was, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6684, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
          __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6684, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6685:                 self.reset()

      __pyx_t_4 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_reset, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6685, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6686:                 self.current_timestep += 1

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6686, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6686, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_t_4) < 0) __PYX_ERR(0, 6686, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6687:                 if STATE_CONSISTENCY_CHECK_AND_RECOVERY and (action_queue_desync or planning_base_state_outdated):

      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_STATE_CONSISTENCY_CHECK_AND_RECO); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6687, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6687, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_12) {
      } else {
        __pyx_t_2 = __pyx_t_12;
        goto __pyx_L22_bool_binop_done;
      }
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_action_queue_desync); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6687, __pyx_L1_error)
      if (!__pyx_t_12) {
      } else {
        __pyx_t_2 = __pyx_t_12;
        goto __pyx_L22_bool_binop_done;
      }
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_planning_base_state_outdated); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6687, __pyx_L1_error)
      __pyx_t_2 = __pyx_t_12;
      __pyx_L22_bool_binop_done:;
      if (__pyx_t_2) {
/* … */
      }

+6688:                     debug_print("Neo probably crashed or something because the internal state is all messed up. Welp, let's try this again.")

        __pyx_t_1 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6688, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_5))) {
          __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
          assert(__pyx_t_1);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
          __Pyx_INCREF(__pyx_t_1);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_mstate_global->__pyx_kp_u_Neo_probably_crashed_or_somethin};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6688, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6689:                     recovering_from_crash = True

        __pyx_v_recovering_from_crash = 1;

+6690:                 if timestep_mismatch:

      if (__pyx_v_timestep_mismatch) {
/* … */
      }

+6691:                     self.current_timestep = game_state.sim_frame

        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_sim_frame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6691, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep, __pyx_t_4) < 0) __PYX_ERR(0, 6691, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 6692: 

+6693:         if self.current_timestep == 0:

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6693, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6693, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_2) {
/* … */
  }

 6694:             # Only do these on the first timestep

+6695:             inspect_scenario(game_state, ship_state)

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_inspect_scenario); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6695, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_game_state, __pyx_v_ship_state};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6695, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 6696:         # debug_print(f"\n\nTimestep {self.current_timestep}, ship id {ship_state.id} is at {ship_state.position[0]} {ship_state.position[1]}")

 6697: 

+6698:         if not self.init_done:

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_init_done); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6698, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6698, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_12 = (!__pyx_t_2);
  if (__pyx_t_12) {
/* … */
  }

+6699:             self.finish_init(game_state, ship_state)

    __pyx_t_1 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_game_state, __pyx_v_ship_state};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_finish_init, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6699, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6700:             self.init_done = True

    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_init_done, Py_True) < 0) __PYX_ERR(0, 6700, __pyx_L1_error)

+6701:         self.performance_controller_enter()

  __pyx_t_1 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_performance_controller_enter, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6701, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6702:         iterations_boost = False

  __pyx_v_iterations_boost = 0;

+6703:         if self.current_timestep == 0:

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6703, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_12 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6703, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_12) {
/* … */
  }

+6704:             iterations_boost = True

    __pyx_v_iterations_boost = 1;

+6705:         if self.other_ships_exist:

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6705, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6705, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_12) {
/* … */
    goto __pyx_L29;
  }

 6706:             # We cannot use deterministic mode to plan ahead

 6707:             # We can still try to plan ahead, but we need to compare the predicted state with the actual state

 6708:             # Note that if the other ship dies, then we will switch from this case to the case where other ships don't exist

 6709: 

 6710:             # Since other ships exist right now and the game isn't deterministic, we can die at any time even during the middle of a planned maneuver where we SHOULD survive.

 6711:             # Or maybe we planned to die at the end of the maneuver, but we died in the middle instead. That's a sneaky case that's possible too. Handle all of these!

 6712:             # Check for that case:

+6713:             unexpected_death = False

    __pyx_v_unexpected_death = 0;

 6714:             # If we're dead/respawning but we didn't plan a respawn maneuver for it, OR if we do expect to die at the end of the maneuver, however we actually died mid-maneuver

 6715:             #print(f"{ship_state.is_respawning=}, ts: {self.current_timestep}, Action queue length: {len(self.action_queue)}")

 6716:             # Originally I thought it'd be a necessary condition to check (not self.last_timestep_ship_is_respawning and ship_state.is_respawning and ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for) however WE DO NOT want to check that the last timestep we weren't respawning!

 6717:             # Because a sneaky edge case is, what if we did a respawn maneuver, and then we began to shoot in the middle of the respawn maneuver RIGHT AS the other ship is inside of us? Then we stay in the respawning state without ever getting out of it, but we just lose a life. Losing a life is the main thing we need to check for! And yes, this is an edge case I experienced and spent an hour tracking down.

+6718:             if (ship_state.is_respawning and ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for) or (self.action_queue and not self.last_timestep_ship_is_respawning and ship_state.is_respawning and ship_state.lives_remaining in self.lives_remaining_that_we_did_respawn_maneuver_for):

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (!__pyx_t_2) {
      goto __pyx_L32_next_or;
    } else {
    }
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_4, __pyx_t_1, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (!__pyx_t_2) {
    } else {
      __pyx_t_12 = __pyx_t_2;
      goto __pyx_L31_bool_binop_done;
    }
    __pyx_L32_next_or:;
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_2) {
    } else {
      __pyx_t_12 = __pyx_t_2;
      goto __pyx_L31_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_ship_is_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_10 = (!__pyx_t_2);
    if (__pyx_t_10) {
    } else {
      __pyx_t_12 = __pyx_t_10;
      goto __pyx_L31_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (__pyx_t_10) {
    } else {
      __pyx_t_12 = __pyx_t_10;
      goto __pyx_L31_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_10 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_4, Py_EQ)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6718, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_12 = __pyx_t_10;
    __pyx_L31_bool_binop_done:;
    if (__pyx_t_12) {
/* … */
    }

+6719:                 print_explanation(f"Ouch, I died in the middle of a maneuver where I expected to survive, due to other ships being present!", self.current_timestep)

      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6719, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6719, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_mstate_global->__pyx_kp_u_Ouch_I_died_in_the_middle_of_a_m, __pyx_t_3};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6719, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 6720:                 #debug_print(f"I have {ship_state.lives_remaining} lives left, and here's the set of lives left we did respawn maneuvers for: {self.lives_remaining_that_we_did_respawn_maneuver_for}")  # REMOVE_FOR_COMPETITION

 6721:                 # Clear the move queue, since previous moves have been invalidated by us taking damage

+6722:                 self.action_queue.clear()

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6722, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = __pyx_t_3;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6722, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6723:                 self.actioned_timesteps.clear()  # If we don't clear it, we'll have duplicated moves since we have to overwrite our planned moves to get to safety, which means enqueuing moves on timesteps we already enqueued moves for.

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actioned_timesteps); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6723, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __pyx_t_5;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6723, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6724:                 self.fire_next_timestep_flag = False  # If we were planning on shooting this timestep but we unexpectedly got hit, DO NOT SHOOT! Actually even if we didn't reset this variable here, we'd only shoot after the respawn maneuver is done and then we'd miss a shot. And yes that was a bug that I fixed lmao

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 6724, __pyx_L1_error)

 6725:                 # self.game_state_to_base_planning = None

+6726:                 self.sims_this_planning_period.clear()

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6726, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = __pyx_t_3;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6726, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6727:                 self.best_fitness_this_planning_period_index = INT_NEG_INF

      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6727, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_4) < 0) __PYX_ERR(0, 6727, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6728:                 self.best_fitness_this_planning_period = -INFINITY

      __pyx_t_4 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6728, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_t_4) < 0) __PYX_ERR(0, 6728, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6729:                 self.second_best_fitness_this_planning_period_index = INT_NEG_INF

      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6729, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_4) < 0) __PYX_ERR(0, 6729, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6730:                 self.second_best_fitness_this_planning_period = -INFINITY

      __pyx_t_4 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6730, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_4) < 0) __PYX_ERR(0, 6730, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6731:                 self.base_gamestate_analysis = None

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestate_analysis, Py_None) < 0) __PYX_ERR(0, 6731, __pyx_L1_error)

+6732:                 unexpected_death = True

      __pyx_v_unexpected_death = 1;

+6733:                 iterations_boost = True

      __pyx_v_iterations_boost = 1;

+6734:                 if ship_state.lives_remaining in self.lives_remaining_that_we_did_respawn_maneuver_for:

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6734, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6734, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_12 = (__Pyx_PySequence_ContainsTF(__pyx_t_4, __pyx_t_3, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6734, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_12) {
/* … */
      }

 6735:                     # We expected to die at the end of the maneuver, however we actually died mid-maneuver, so we have to revoke the respawn maneuver we had planned, and plan a new one.

 6736:                     # Removing the life remaining number from this set will allow us to plan a new maneuver for this number of lives remaining

 6737:                     #debug_print("GOTCHA, this life remaining shouldn't be in here! Yoink!")  # REMOVE_FOR_COMPETITION

+6738:                     self.lives_remaining_that_we_did_respawn_maneuver_for.remove(ship_state.lives_remaining)

        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6738, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_4 = __pyx_t_5;
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6738, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_1};
          __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_remove, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6738, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6739:             unexpected_survival = False

    __pyx_v_unexpected_survival = 0;

 6740:             # If we're alive at the end of a maneuver but we're expecting to be dead at the end of the maneuver and we've planned a respawn maneuver

 6741:             #if self.game_state_to_base_planning is not None:

 6742:             #    print(f"Checking for unexpected survival: {ship_state.is_respawning=} {self.game_state_to_base_planning['ship_state'].is_respawning=} {self.game_state_to_base_planning['respawning']=}")

+6743:             if not self.action_queue and self.game_state_to_base_planning is not None and not ship_state.is_respawning and self.game_state_to_base_planning['ship_state'].is_respawning and self.game_state_to_base_planning['respawning']:

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_2 = (!__pyx_t_10);
    if (__pyx_t_2) {
    } else {
      __pyx_t_12 = __pyx_t_2;
      goto __pyx_L39_bool_binop_done;
    }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = (__pyx_t_3 != Py_None);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_2) {
    } else {
      __pyx_t_12 = __pyx_t_2;
      goto __pyx_L39_bool_binop_done;
    }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_10 = (!__pyx_t_2);
    if (__pyx_t_10) {
    } else {
      __pyx_t_12 = __pyx_t_10;
      goto __pyx_L39_bool_binop_done;
    }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_10) {
    } else {
      __pyx_t_12 = __pyx_t_10;
      goto __pyx_L39_bool_binop_done;
    }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6743, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_12 = __pyx_t_10;
    __pyx_L39_bool_binop_done:;
    if (__pyx_t_12) {
/* … */
    }

 6744:                 # We thought this maneuver would end in us dying, with the next move being a respawn maneuver. However this is not the case. We're alive at the end of the maneuver! This must be because the other ship saved us by shooting an asteroid that was going to hit us, or something.

 6745:                 # This assertion isn't true because we could be doing a respawn maneuver, dying, and doing another respawn maneuver!

 6746:                 # assert not self.last_timestep_ship_is_respawning

+6747:                 print_explanation(f"\nI thought I would die, but the other ship saved me!!!", self.current_timestep)

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6747, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_1))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_I_thought_I_would_die_but_the_o, __pyx_t_4};
        __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6747, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 6748:                 # Clear the move queue, since previous moves have been invalidated by us taking damage

+6749:                 self.action_queue.clear()

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6749, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = __pyx_t_4;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6749, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6750:                 self.actioned_timesteps.clear()  # If we don't clear it, we'll have duplicated moves since we have to overwrite our planned moves to get to safety, which means enqueuing moves on timesteps we already enqueued moves for.

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actioned_timesteps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6750, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __pyx_t_1;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6750, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6751:                 self.fire_next_timestep_flag = False  # This should be false anyway!

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 6751, __pyx_L1_error)

 6752:                 # self.game_state_to_base_planning = None

+6753:                 self.sims_this_planning_period.clear()

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6753, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = __pyx_t_4;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6753, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6754:                 self.best_fitness_this_planning_period_index = INT_NEG_INF

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6754, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2, __pyx_t_5) < 0) __PYX_ERR(0, 6754, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6755:                 self.best_fitness_this_planning_period = -INFINITY

      __pyx_t_5 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6755, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio, __pyx_t_5) < 0) __PYX_ERR(0, 6755, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6756:                 self.second_best_fitness_this_planning_period_index = INT_NEG_INF

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6756, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin_2, __pyx_t_5) < 0) __PYX_ERR(0, 6756, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6757:                 self.second_best_fitness_this_planning_period = -INFINITY

      __pyx_t_5 = PyFloat_FromDouble((-INFINITY)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6757, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin, __pyx_t_5) < 0) __PYX_ERR(0, 6757, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6758:                 self.base_gamestate_analysis = None

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestate_analysis, Py_None) < 0) __PYX_ERR(0, 6758, __pyx_L1_error)

+6759:                 iterations_boost = True

      __pyx_v_iterations_boost = 1;

+6760:                 unexpected_survival = True

      __pyx_v_unexpected_survival = 1;

 6761:                 # Yoink this life remaining from the respawn maneuvers, since we no longer are doing one

+6762:                 if (ship_state.lives_remaining - 1) in self.lives_remaining_that_we_did_respawn_maneuver_for:

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6762, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyLong_SubtractObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6762, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6762, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_12 = (__Pyx_PySequence_ContainsTF(__pyx_t_4, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6762, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_12) {
/* … */
      }

 6763:                     # We need to subtract one from the lives remaining, because when we added it, it was from a simulated ship that had one fewer life. In reality we never lost that life, so we subtract one from our actual lives.

+6764:                     self.lives_remaining_that_we_did_respawn_maneuver_for.remove(ship_state.lives_remaining - 1)

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6764, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1;
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6764, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_9 = __Pyx_PyLong_SubtractObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6764, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_9};
          __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_remove, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6764, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
        }
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 6765:             # set up the actions planning

+6766:             if unexpected_death:

    if (__pyx_v_unexpected_death) {
/* … */
      goto __pyx_L45;
    }

 6767:                 # We need to refresh the state if we died unexpectedly

+6768:                 print_explanation(f"Ouch! Due to the other ship, I unexpectedly died!", self.current_timestep)

      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6768, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6768, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_mstate_global->__pyx_kp_u_Ouch_Due_to_the_other_ship_I_une, __pyx_t_4};
        __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6768, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6769:                 if self.game_state_to_base_planning is None:

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6769, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_12 = (__pyx_t_5 == Py_None);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_12) {
/* … */
      }

+6770:                     debug_print(f"WARNING: The game state to base planning was none. This better be because I'm recovering from a controller exception!")  # REMOVE_FOR_COMPETITION

        __pyx_t_9 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6770, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_9);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_9);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_WARNING_The_game_state_to_base_p};
          __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6770, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
        }
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6771:                     self.game_state_to_base_planning = {

        if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning, __pyx_t_5) < 0) __PYX_ERR(0, 6771, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6772:                         'timestep': self.current_timestep,

        __pyx_t_5 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_4) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6773:                         'respawning': ship_state.is_respawning and ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for,

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6773, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6773, __pyx_L1_error)
        if (__pyx_t_12) {
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        } else {
          __Pyx_INCREF(__pyx_t_9);
          __pyx_t_4 = __pyx_t_9;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          goto __pyx_L47_bool_binop_done;
        }
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6773, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6773, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_12 = (__Pyx_PySequence_ContainsTF(__pyx_t_9, __pyx_t_1, Py_NE)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6773, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6773, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1;
        __pyx_t_1 = 0;
        __pyx_L47_bool_binop_done:;
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_respawning, __pyx_t_4) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6774:                         'ship_state': ship_state,

        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_v_ship_state) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)

+6775:                         'game_state': game_state,

        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_v_game_state) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_mstate_global->__pyx_float_3_0) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)

 6776:                         'ship_respawn_timer': 3.0,

+6777:                         'asteroids_pending_death': {},

        __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6777, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_4) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6778:                         'forecasted_asteroid_splits': [],

        __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6778, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_4) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6779:                         'last_timestep_fired': INT_NEG_INF,

        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6779, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_4) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6780:                         'last_timestep_mined': INT_NEG_INF,

        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6780, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_4) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = PySet_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6781, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_4) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 6781:                         'mine_positions_placed': set(),

+6782:                         'fire_next_timestep_flag': False,

        if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 6772, __pyx_L1_error)

 6783:                     }

+6784:                 assert self.game_state_to_base_planning is not None

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6784, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_12 = (__pyx_t_5 != Py_None);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_12)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6784, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6784, __pyx_L1_error)
      #endif

+6785:                 self.game_state_to_base_planning = {

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning, __pyx_t_5) < 0) __PYX_ERR(0, 6785, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6786:                     'timestep': self.current_timestep,

      __pyx_t_5 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_4) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6787:                     'respawning': ship_state.is_respawning and ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for,

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6787, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6787, __pyx_L1_error)
      if (__pyx_t_12) {
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      } else {
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L49_bool_binop_done;
      }
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6787, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6787, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_12 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_9, Py_NE)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6787, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6787, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_4 = __pyx_t_9;
      __pyx_t_9 = 0;
      __pyx_L49_bool_binop_done:;
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_respawning, __pyx_t_4) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6788:                     'ship_state': ship_state,

      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_v_ship_state) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)

+6789:                     'game_state': game_state,

      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_v_game_state) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_mstate_global->__pyx_float_3_0) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)

 6790:                     'ship_respawn_timer': 3.0,

+6791:                     'asteroids_pending_death': {},

      __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6791, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_4) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6792:                     'forecasted_asteroid_splits': [],

      __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6792, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_4) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6793:                     'last_timestep_fired': self.game_state_to_base_planning['last_timestep_fired'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6793, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6793, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_9) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6794:                     'last_timestep_mined': self.game_state_to_base_planning['last_timestep_mined'],

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6794, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6794, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_4) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6795:                     'mine_positions_placed': self.game_state_to_base_planning['mine_positions_placed'],

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6795, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6795, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_9) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6796:                     'fire_next_timestep_flag': False,

      if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 6786, __pyx_L1_error)

 6797:                 }

 6798: 

+6799:                 if self.game_state_to_base_planning['respawning']:

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6799, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6799, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6799, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (__pyx_t_12) {
/* … */
      }

+6800:                     debug_print(f"Adding to lives remaining that we did respawn for, in the unexpected death: {ship_state.lives_remaining}")  # REMOVE_FOR_COMPETITION

        __pyx_t_5 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6800, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6800, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6800, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Adding_to_lives_remaining_that_w, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6800, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_5);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_1};
          __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6800, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6801:                     self.lives_remaining_that_we_did_respawn_maneuver_for.add(ship_state.lives_remaining)

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6801, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1;
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6801, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5};
          __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6801, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
        }
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6802:             elif unexpected_survival:

    if (__pyx_v_unexpected_survival) {
/* … */
      goto __pyx_L45;
    }

+6803:                 debug_print(f"Unexpected survival, the ship state is {ship_state}")  # REMOVE_FOR_COMPETITION

      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6803, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_ship_state, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6803, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Unexpected_survival_the_ship_sta, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6803, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3};
        __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6803, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 6804:                 # We need to refresh the state if we survived unexpectedly. Technically if we still had the remainder of the maneuver from before we could use that, but it's easier to just make a new maneuver from this starting point.

+6805:                 assert self.game_state_to_base_planning is not None

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6805, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_12 = (__pyx_t_9 != Py_None);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_12)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6805, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6805, __pyx_L1_error)
      #endif

+6806:                 self.game_state_to_base_planning = {

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning, __pyx_t_9) < 0) __PYX_ERR(0, 6806, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6807:                     'timestep': self.current_timestep,

      __pyx_t_9 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_5) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6808:                     'respawning': ship_state.is_respawning and ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for,

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6808, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6808, __pyx_L1_error)
      if (__pyx_t_12) {
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      } else {
        __Pyx_INCREF(__pyx_t_3);
        __pyx_t_5 = __pyx_t_3;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        goto __pyx_L52_bool_binop_done;
      }
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6808, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6808, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_12 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_t_1, Py_NE)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6808, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6808, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_5 = __pyx_t_1;
      __pyx_t_1 = 0;
      __pyx_L52_bool_binop_done:;
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_respawning, __pyx_t_5) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6809:                     'ship_state': ship_state,

      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_v_ship_state) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)

+6810:                     'game_state': game_state,

      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_v_game_state) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)

 6811:                     'ship_respawn_timer': 0.0,

+6812:                     'asteroids_pending_death': {},

      __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6812, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_5) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6813:                     'forecasted_asteroid_splits': [],

      __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6813, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_5) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6814:                     'last_timestep_fired': self.game_state_to_base_planning['last_timestep_fired'],

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6814, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_last_timestep_fired); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6814, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_1) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6815:                     'last_timestep_mined': self.game_state_to_base_planning['last_timestep_mined'],

      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6815, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_last_timestep_mined); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6815, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_5) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6816:                     'mine_positions_placed': self.game_state_to_base_planning['mine_positions_placed'],

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6816, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_mine_positions_placed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6816, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_1) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6817:                     'fire_next_timestep_flag': False,

      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 6807, __pyx_L1_error)

 6818:                 }

+6819:             elif not self.game_state_to_base_planning:

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6819, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6819, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_10 = (!__pyx_t_12);
    if (__pyx_t_10) {
/* … */
    }
    __pyx_L45:;

+6820:                 self.game_state_to_base_planning = {

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning, __pyx_t_9) < 0) __PYX_ERR(0, 6820, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6821:                     'timestep': self.current_timestep,

      __pyx_t_9 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_1) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6822:                     'respawning': ship_state.is_respawning and ship_state.lives_remaining not in self.lives_remaining_that_we_did_respawn_maneuver_for,

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6822, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6822, __pyx_L1_error)
      if (__pyx_t_10) {
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      } else {
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_1 = __pyx_t_5;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        goto __pyx_L54_bool_binop_done;
      }
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6822, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6822, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_10 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_t_3, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6822, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6822, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __pyx_t_3;
      __pyx_t_3 = 0;
      __pyx_L54_bool_binop_done:;
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_respawning, __pyx_t_1) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6823:                     'ship_state': ship_state,

      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_v_ship_state) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)

+6824:                     'game_state': game_state,

      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_v_game_state) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_mstate_global->__pyx_float_0_0) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)

 6825:                     'ship_respawn_timer': 0.0,

+6826:                     'asteroids_pending_death': {},

      __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6826, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_1) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6827:                     'forecasted_asteroid_splits': [],

      __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6827, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_1) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6828:                     'last_timestep_fired': INT_NEG_INF,

      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6828, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_1) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6829:                     'last_timestep_mined': INT_NEG_INF,

      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6829, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_1) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6830, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_1) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 6830:                     'mine_positions_placed': set(),

+6831:                     'fire_next_timestep_flag': False,

      if (PyDict_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 6821, __pyx_L1_error)

 6832:                 }

+6833:                 if self.game_state_to_base_planning['respawning']:

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6833, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6833, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6833, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (__pyx_t_10) {
/* … */
      }

 6834:                     # print(f"Adding to lives remaining that we did respawn for, in actions: {ship_state.lives_remaining}")

+6835:                     self.lives_remaining_that_we_did_respawn_maneuver_for.add(ship_state.lives_remaining)

        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lives_remaining_that_we_did_resp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6835, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_9 = __pyx_t_3;
        __Pyx_INCREF(__pyx_t_9);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6835, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_5};
          __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6835, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+6836:                 assert bool(self.game_state_to_base_planning['ship_respawn_timer']) == self.game_state_to_base_planning['ship_state'].is_respawning  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyBool_FromLong((!(!__pyx_t_10))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6836, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_10)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6836, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6836, __pyx_L1_error)
      #endif

 6837: 

+6838:             if self.action_queue:

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6838, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6838, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_10) {
/* … */
      goto __pyx_L57;
    }

+6839:                 self.plan_action(self.other_ships_exist, False, iterations_boost, False)

      __pyx_t_1 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_iterations_boost); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[5] = {__pyx_t_1, __pyx_t_3, Py_False, __pyx_t_9, Py_False};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_plan_action, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6839, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 6840:             else:

 6841:                 # Refresh the base state now that we have the true base state!

 6842:                 # debug_print('REFRESHING BASE STATE FOR STATIONARY ON TS', self.current_timestep)

+6843:                 self.game_state_to_base_planning['ship_state'] = ship_state

    /*else*/ {
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6843, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_v_ship_state) < 0))) __PYX_ERR(0, 6843, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6844:                 self.game_state_to_base_planning['game_state'] = game_state

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6844, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_v_game_state) < 0))) __PYX_ERR(0, 6844, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+6845:                 if not self.game_state_to_base_planning['ship_state'].is_respawning and bool(self.game_state_to_base_planning['ship_respawn_timer']):

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6845, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6845, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6845, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6845, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_2 = (!__pyx_t_12);
      if (__pyx_t_2) {
      } else {
        __pyx_t_10 = __pyx_t_2;
        goto __pyx_L59_bool_binop_done;
      }
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6845, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6845, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6845, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_10 = (!(!__pyx_t_2));
      __pyx_L59_bool_binop_done:;
      if (__pyx_t_10) {
/* … */
      }

 6846:                     # We're not respawning but the ship respawn timer is non-zero, so we're gonna fix this and make it consistent!

+6847:                     self.game_state_to_base_planning['ship_respawn_timer'] = 0.0

        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6847, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_mstate_global->__pyx_float_0_0) < 0))) __PYX_ERR(0, 6847, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6848:                 assert bool(self.game_state_to_base_planning['ship_respawn_timer']) == self.game_state_to_base_planning['ship_state'].is_respawning, f"Mismatch: {self.game_state_to_base_planning['ship_respawn_timer']=}, {self.game_state_to_base_planning['ship_state'].is_respawning=}"  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyBool_FromLong((!(!__pyx_t_10))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_9, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6848, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_10)) {
          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_9), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_9), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_Mismatch_self_game_state_to_base;
          __pyx_t_13[1] = __pyx_t_3;
          __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u_self_game_state_to_base_plannin_2;
          __pyx_t_13[3] = __pyx_t_5;
          __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, 65 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 63 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5));
          if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6848, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_9, 0, 0);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __PYX_ERR(0, 6848, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6848, __pyx_L1_error)
      #endif

 6849:                 # When there's other ships, stationary targetting is the LAST thing done, just so it can be based off of the reality state

 6850:                 # The base state is exact on the final planning timestep, since the base state is the state we're on right now

 6851:                 # if len(get_other_ships(game_state, self.ship_id_internal)) == 0:

 6852:                 #    debug_print("\n\nWe're alone already. Injecting the following game state:")

 6853:                 #    debug_print(game_state)

+6854:                 self.plan_action(self.other_ships_exist, True, iterations_boost, True)

      __pyx_t_5 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6854, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_iterations_boost); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6854, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[5] = {__pyx_t_5, __pyx_t_3, Py_True, __pyx_t_1, Py_True};
        __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_plan_action, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6854, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+6855:                 assert self.best_fitness_this_planning_period_index != INT_NEG_INF  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6855, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6855, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_9, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6855, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6855, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_10)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6855, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6855, __pyx_L1_error)
      #endif

 6856:                 #index_according_to_lives_remaining = min(3, self.game_state_to_base_planning['ship_state'].lives_remaining)

+6857:                 while len(self.sims_this_planning_period) < (get_min_maneuver_per_period_search_iterations_if_will_die(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)) if self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness_breakdown'][5] == 0.0 else (get_min_respawn_per_period_search_iterations(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)) if self.game_state_to_base_planning['respawning'] else get_min_maneuver_per_period_search_iterations(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)))):

      while (1) {
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_11 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_10 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_4, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (__pyx_t_10) {
          __pyx_t_5 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_7);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_14 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_15);
          __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_16);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_15))) {
            __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_15);
            assert(__pyx_t_14);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15);
            __Pyx_INCREF(__pyx_t_14);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_15, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_t_16};
            __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
            __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_8);
          }
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_9))) {
            __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9);
            assert(__pyx_t_5);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
            __Pyx_INCREF(__pyx_t_5);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_7, __pyx_t_8};
            __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
          }
          __pyx_t_1 = __pyx_t_4;
          __pyx_t_4 = 0;
        } else {
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6857, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (__pyx_t_2) {
            __pyx_t_9 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_get_min_respawn_per_period_searc); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
            __pyx_t_16 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_14);
            __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_14))) {
              __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_14);
              assert(__pyx_t_16);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14);
              __Pyx_INCREF(__pyx_t_16);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_14, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_16, __pyx_t_17};
              __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
              if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6857, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_15);
            }
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_7))) {
              __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
              assert(__pyx_t_9);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
              __Pyx_INCREF(__pyx_t_9);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_5, __pyx_t_15};
              __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
              if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6857, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_8);
            }
            __pyx_t_4 = __pyx_t_8;
            __pyx_t_8 = 0;
          } else {
            __pyx_t_7 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_15);
            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __pyx_t_14 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6857, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_16);
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_17))) {
              __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_17);
              assert(__pyx_t_14);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_17);
              __Pyx_INCREF(__pyx_t_14);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_17, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_t_16};
              __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
              __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6857, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_9);
            }
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_15))) {
              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_15);
              assert(__pyx_t_7);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15);
              __Pyx_INCREF(__pyx_t_7);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_15, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_9};
              __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
              if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6857, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_8);
            }
            __pyx_t_4 = __pyx_t_8;
            __pyx_t_8 = 0;
          }
          __pyx_t_1 = __pyx_t_4;
          __pyx_t_4 = 0;
        }
        __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6857, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (!__pyx_t_10) break;

 6858:                     # Planning extra iterations to reach minimum threshold!

 6859:                     # print(f"Planning extra iterations to reach minimum threshold! {len(self.sims_this_planning_period)}")

+6860:                     self.plan_action(self.other_ships_exist, True, False, False)

        __pyx_t_1 = __pyx_v_self;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6860, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_1, __pyx_t_3, Py_True, Py_False, Py_False};
          __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_plan_action, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6860, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      }

+6861:                 assert self.current_timestep == self.game_state_to_base_planning['timestep']  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6861, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6861, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6861, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6861, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6861, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_10)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6861, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6861, __pyx_L1_error)
      #endif

 6862:                 #extra_planning_loop_count: int = 0

+6863:                 if not self.decide_next_action(game_state, ship_state):  # Since other ships exist and this is non-deterministic, we constantly feed in the updated reality

      __pyx_t_1 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_game_state, __pyx_v_ship_state};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_decide_next_action, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6863, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6863, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_2 = (!__pyx_t_10);
      if (__pyx_t_2) {
/* … */
      }

 6864:                     # Most of the time we won't go into this part at all

 6865:                     # This is only for if the decide next action fails due to non-determinism injected by the other ship.

 6866:                     # If the other ship makes our action bad, then we'll do extra search iterations to find something good and to put on a good show

+6867:                     for _ in range(60):

        for (__pyx_t_11 = 0; __pyx_t_11 < 60; __pyx_t_11+=1) {
          __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6867, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_3);
          __pyx_t_3 = 0;

+6868:                         self.plan_action(self.other_ships_exist, True, False, False)

          __pyx_t_1 = __pyx_v_self;
          __Pyx_INCREF(__pyx_t_1);
          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6868, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_6 = 0;
          {
            PyObject *__pyx_callargs[5] = {__pyx_t_1, __pyx_t_4, Py_True, Py_False, Py_False};
            __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_plan_action, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6868, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6869:                         if self.second_best_fitness_this_planning_period > 0.93:

          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_second_best_fitness_this_plannin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6869, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_mstate_global->__pyx_float_0_93, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6869, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6869, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (__pyx_t_2) {
/* … */
          }
        }
        __pyx_L65_break:;

 6870:                             # Good enough, early exit

+6871:                             break

            goto __pyx_L65_break;

 6872:                     #debug_print(f"Going back to do more searching to find a good move. We have {len(self.sims_this_planning_period)} sims so far!")

 6873:                     #extra_planning_loop_count += 1

+6874:                     success = self.decide_next_action(game_state, ship_state)

        __pyx_t_3 = __pyx_v_self;
        __Pyx_INCREF(__pyx_t_3);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_game_state, __pyx_v_ship_state};
          __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_decide_next_action, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6874, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __pyx_v_success = __pyx_t_4;
        __pyx_t_4 = 0;

+6875:                     assert success  # REMOVE_FOR_COMPETITION

        #ifndef CYTHON_WITHOUT_ASSERTIONS
        if (unlikely(__pyx_assertions_enabled())) {
          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_success); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6875, __pyx_L1_error)
          if (unlikely(!__pyx_t_2)) {
            __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
            __PYX_ERR(0, 6875, __pyx_L1_error)
          }
        }
        #else
        if ((1)); else __PYX_ERR(0, 6875, __pyx_L1_error)
        #endif

+6876:                 if len(get_other_ships(game_state, self.ship_id_internal)) == 0:

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_get_other_ships); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6876, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_ship_id_internal); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6876, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_1))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_game_state, __pyx_t_8};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6876, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_t_11 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6876, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_2 = (__pyx_t_11 == 0);
      if (__pyx_t_2) {
/* … */
      }
    }
    __pyx_L57:;

 6877:                     # The other ship just died. I'm now alone!

+6878:                     print_explanation("I'm alone. I can see into the future perfectly now!", self.current_timestep)

        __pyx_t_1 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6878, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6878, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_8))) {
          __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_8);
          assert(__pyx_t_1);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
          __Pyx_INCREF(__pyx_t_1);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_mstate_global->__pyx_kp_u_I_m_alone_I_can_see_into_the_fut_2, __pyx_t_3};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6878, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6879:                     self.simulated_gamestate_history.clear()

        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6879, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_8 = __pyx_t_3;
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
          __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6879, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6880:                     self.set_of_base_gamestate_timesteps.clear()

        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_of_base_gamestate_timesteps); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6880, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_3 = __pyx_t_8;
        __Pyx_INCREF(__pyx_t_3);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
          __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6880, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6881:                     self.other_ships_exist = False

        if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist, Py_False) < 0) __PYX_ERR(0, 6881, __pyx_L1_error)

 6882:         else:

 6883:             # No other ships exist, we're deterministically planning the future

+6884:             if not self.game_state_to_base_planning:

  /*else*/ {
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6884, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6884, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_10 = (!__pyx_t_2);
    if (__pyx_t_10) {
/* … */
    }

 6885:                 # set up the actions planning

+6886:                 if ENABLE_SANITY_CHECKS and not recovering_from_crash:  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6886, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6886, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_2) {
      } else {
        __pyx_t_10 = __pyx_t_2;
        goto __pyx_L70_bool_binop_done;
      }
      __pyx_t_2 = (!__pyx_v_recovering_from_crash);
      __pyx_t_10 = __pyx_t_2;
      __pyx_L70_bool_binop_done:;
      if (__pyx_t_10) {
/* … */
      }

 6887:                     #assert self.current_timestep == 0, "Why is the game state to plan empty when we're not on timestep 0?!"  # REMOVE_FOR_COMPETITION

+6888:                     print("WARNING, Why is the game state to plan empty when we're not on timestep 0?! Maybe we're recovering from a controller exception")  # REMOVE_FOR_COMPETITION

        __pyx_t_8 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_3 = __pyx_builtin_print; 
        __pyx_t_6 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_WARNING_Why_is_the_game_state_to};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6888, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6889:                 if self.current_timestep == 0 or recovering_from_crash:

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6889, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_2 = (__Pyx_PyLong_BoolEqObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6889, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (!__pyx_t_2) {
      } else {
        __pyx_t_10 = __pyx_t_2;
        goto __pyx_L73_bool_binop_done;
      }
      __pyx_t_10 = __pyx_v_recovering_from_crash;
      __pyx_L73_bool_binop_done:;
      if (__pyx_t_10) {
/* … */
      }

+6890:                     iterations_boost = True

        __pyx_v_iterations_boost = 1;

+6891:                 self.game_state_to_base_planning = {

      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning, __pyx_t_4) < 0) __PYX_ERR(0, 6891, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6892:                     'timestep': self.current_timestep,

      __pyx_t_4 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_3) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6893:                     'respawning': False,  # On the first timestep 0, the is_respawning flag is ALWAYS false, even if we spawn inside asteroids.

      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_respawning, Py_False) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)

+6894:                     'ship_state': ship_state,

      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_v_ship_state) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)

+6895:                     'game_state': game_state,

      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_game_state, __pyx_v_game_state) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)
      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer, __pyx_mstate_global->__pyx_int_0) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)

 6896:                     'ship_respawn_timer': 0,

+6897:                     'asteroids_pending_death': {},

      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6897, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death, __pyx_t_3) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6898:                     'forecasted_asteroid_splits': [],

      __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6898, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits, __pyx_t_3) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6899:                     'last_timestep_fired': INT_NEG_INF if not recovering_from_crash else self.current_timestep - 1,  # self.current_timestep - 1, # TODO: CHECK EDGECASE, may need to restore to larger number to be safe

      __pyx_t_10 = (!__pyx_v_recovering_from_crash);
      if (__pyx_t_10) {
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6899, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_3 = __pyx_t_8;
        __pyx_t_8 = 0;
      } else {
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6899, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_1 = __Pyx_PyLong_SubtractObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6899, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_3 = __pyx_t_1;
        __pyx_t_1 = 0;
      }
      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_last_timestep_fired, __pyx_t_3) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+6900:                     'last_timestep_mined': INT_NEG_INF if not recovering_from_crash else self.current_timestep - 1,

      __pyx_t_10 = (!__pyx_v_recovering_from_crash);
      if (__pyx_t_10) {
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6900, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __pyx_t_1;
        __pyx_t_1 = 0;
      } else {
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6900, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_8 = __Pyx_PyLong_SubtractObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6900, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_3 = __pyx_t_8;
        __pyx_t_8 = 0;
      }
      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_last_timestep_mined, __pyx_t_3) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PySet_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6901, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_mine_positions_placed, __pyx_t_3) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 6901:                     'mine_positions_placed': set(),

+6902:                     'fire_next_timestep_flag': False,

      if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_fire_next_timestep_flag, Py_False) < 0) __PYX_ERR(0, 6892, __pyx_L1_error)

 6903:                 }

+6904:                 if recovering_from_crash:

      if (__pyx_v_recovering_from_crash) {
/* … */
      }

+6905:                     print_explanation(f"Recovering from crash! Setting the base gamestate. The timestep is {self.current_timestep}", self.current_timestep)

        __pyx_t_3 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_print_explanation); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6905, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6905, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6905, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Recovering_from_crash_Setting_th, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6905, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6905, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_8))) {
          __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
          assert(__pyx_t_3);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_1, __pyx_t_15};
          __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6905, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6906:                 assert bool(self.game_state_to_base_planning['ship_respawn_timer']) == self.game_state_to_base_planning['ship_state'].is_respawning, f"{self.game_state_to_base_planning['ship_respawn_timer']=} {self.game_state_to_base_planning['ship_state'].is_respawning=}"  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_8 = __Pyx_PyBool_FromLong((!(!__pyx_t_10))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_15 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = PyObject_RichCompare(__pyx_t_8, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6906, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        if (unlikely(!__pyx_t_10)) {
          __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_15);
          __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_ship_respawn_timer); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
          __pyx_t_15 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_15);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_self_game_state_to_base_planning_3;
          __pyx_t_13[1] = __pyx_t_15;
          __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u_self_game_state_to_base_plannin_3;
          __pyx_t_13[3] = __pyx_t_8;
          __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, 55 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 62 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8));
          if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6906, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_4, 0, 0);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __PYX_ERR(0, 6906, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6906, __pyx_L1_error)
      #endif

 6907:             # No matter what, spend some time evaluating the best action from the next predicted state

 6908:             # When no ships are around, the stationary targetting is the first thing done

+6909:             if not self.sims_this_planning_period:

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6909, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6909, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_2 = (!__pyx_t_10);
    if (__pyx_t_2) {
/* … */
      goto __pyx_L76;
    }

+6910:                 self.plan_action(self.other_ships_exist, True, iterations_boost, True)

      __pyx_t_8 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6910, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_iterations_boost); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6910, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[5] = {__pyx_t_8, __pyx_t_15, Py_True, __pyx_t_1, Py_True};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_plan_action, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6910, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 6911:             else:

+6912:                 self.plan_action(self.other_ships_exist, True, iterations_boost, False)

    /*else*/ {
      __pyx_t_1 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6912, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_iterations_boost); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6912, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[5] = {__pyx_t_1, __pyx_t_15, Py_True, __pyx_t_8, Py_False};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_plan_action, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6912, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
    __pyx_L76:;

+6913:             if not self.action_queue:

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6913, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6913, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_10 = (!__pyx_t_2);
    if (__pyx_t_10) {
/* … */
    }
  }
  __pyx_L29:;

+6914:                 assert self.best_fitness_this_planning_period_index != INT_NEG_INF  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6914, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_INT_NEG_INF); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6914, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_15 = PyObject_RichCompare(__pyx_t_4, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6914, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6914, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        if (unlikely(!__pyx_t_10)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6914, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6914, __pyx_L1_error)
      #endif

 6915:                 #index_according_to_lives_remaining = min(3, self.game_state_to_base_planning['ship_state'].lives_remaining)

+6916:                 while len(self.sims_this_planning_period) < (get_min_maneuver_per_period_search_iterations_if_will_die(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)) if self.sims_this_planning_period[self.best_fitness_this_planning_period_index]['fitness_breakdown'][5] == 0.0 else (get_min_respawn_per_period_search_iterations(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)) if self.game_state_to_base_planning['respawning'] else get_min_maneuver_per_period_search_iterations(self.game_state_to_base_planning['ship_state'].lives_remaining, weighted_average(overall_fitness_record)))):

      while (1) {
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_11 = PyObject_Length(__pyx_t_15); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __pyx_t_15 = PyLong_FromSsize_t(__pyx_t_11); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_sims_this_planning_period); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_best_fitness_this_planning_perio_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_fitness_breakdown); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __pyx_t_10 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_3, __pyx_mstate_global->__pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (__pyx_t_10) {
          __pyx_t_1 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __pyx_t_7 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
          __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_16);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_17))) {
            __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_17);
            assert(__pyx_t_7);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_17);
            __Pyx_INCREF(__pyx_t_7);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_17, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_16};
            __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
          }
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_4))) {
            __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
            assert(__pyx_t_1);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
            __Pyx_INCREF(__pyx_t_1);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_9, __pyx_t_5};
            __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __pyx_t_8 = __pyx_t_3;
          __pyx_t_3 = 0;
        } else {
          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_respawning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6916, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (__pyx_t_2) {
            __pyx_t_4 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_get_min_respawn_per_period_searc); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_9);
            __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
            __pyx_t_16 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
            __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_14);
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_7))) {
              __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7);
              assert(__pyx_t_16);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
              __Pyx_INCREF(__pyx_t_16);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_16, __pyx_t_14};
              __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
              __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
              if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6916, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_17);
            }
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_9))) {
              __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
              assert(__pyx_t_4);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
              __Pyx_INCREF(__pyx_t_4);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_t_17};
              __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6916, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
            }
            __pyx_t_3 = __pyx_t_5;
            __pyx_t_5 = 0;
          } else {
            __pyx_t_9 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_get_min_maneuver_per_period_sear_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_lives_remaining); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_7 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_weighted_average); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_14);
            __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_overall_fitness_record); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6916, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_16);
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_14))) {
              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_14);
              assert(__pyx_t_7);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14);
              __Pyx_INCREF(__pyx_t_7);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_14, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_16};
              __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
              __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
              if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6916, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_4);
            }
            __pyx_t_6 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_17))) {
              __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_17);
              assert(__pyx_t_9);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_17);
              __Pyx_INCREF(__pyx_t_9);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_17, __pyx__function);
              __pyx_t_6 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_t_4};
              __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6916, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_5);
            }
            __pyx_t_3 = __pyx_t_5;
            __pyx_t_5 = 0;
          }
          __pyx_t_8 = __pyx_t_3;
          __pyx_t_3 = 0;
        }
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_15, __pyx_t_8, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6916, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (!__pyx_t_10) break;

 6917:                     # Planning extra iterations to reach minimum threshold!

 6918:                     # print("Planning extra iterations to reach minimum threshold!")

+6919:                     self.plan_action(self.other_ships_exist, True, False, False)

        __pyx_t_8 = __pyx_v_self;
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6919, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_8, __pyx_t_15, Py_True, Py_False, Py_False};
          __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_plan_action, __pyx_callargs+__pyx_t_6, (5-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6919, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      }

 6920:                 # Nothing's in the action queue. Evaluate the current situation and figure out the best course of action

+6921:                 if not self.current_timestep == self.game_state_to_base_planning['timestep'] and not recovering_from_crash:

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6921, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6921, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6921, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_15 = PyObject_RichCompare(__pyx_t_3, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6921, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6921, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __pyx_t_12 = (!__pyx_t_2);
      if (__pyx_t_12) {
      } else {
        __pyx_t_10 = __pyx_t_12;
        goto __pyx_L81_bool_binop_done;
      }
      __pyx_t_12 = (!__pyx_v_recovering_from_crash);
      __pyx_t_10 = __pyx_t_12;
      __pyx_L81_bool_binop_done:;
      if (unlikely(__pyx_t_10)) {
/* … */
      }

+6922:                     raise Exception(f"The actions queue is empty, however the base state's timestep {self.game_state_to_base_planning['timestep']} doesn't match the current timestep {self.current_timestep}! That's weird.")

        __pyx_t_8 = NULL;
        __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
        __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6922, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __pyx_t_17 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_timestep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6922, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_17, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6922, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6922, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_17, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6922, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __pyx_t_18[0] = __pyx_mstate_global->__pyx_kp_u_The_actions_queue_is_empty_howev;
        __pyx_t_18[1] = __pyx_t_5;
        __pyx_t_18[2] = __pyx_mstate_global->__pyx_kp_u_doesn_t_match_the_current_times;
        __pyx_t_18[3] = __pyx_t_4;
        __pyx_t_18[4] = __pyx_mstate_global->__pyx_kp_u_That_s_weird;
        __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_18, 5, 62 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 36 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 15, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4));
        if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6922, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_6 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_17};
          __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6922, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_15);
        }
        __Pyx_Raise(__pyx_t_15, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __PYX_ERR(0, 6922, __pyx_L1_error)

 6923:                 # debug_print("Decide the next action.")

+6924:                 success = self.decide_next_action(game_state, ship_state)

      __pyx_t_3 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_game_state, __pyx_v_ship_state};
        __pyx_t_15 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_decide_next_action, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6924, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
      }
      __pyx_v_success = __pyx_t_15;
      __pyx_t_15 = 0;

+6925:                 assert success  # REMOVE_FOR_COMPETITION

      #ifndef CYTHON_WITHOUT_ASSERTIONS
      if (unlikely(__pyx_assertions_enabled())) {
        __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_success); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6925, __pyx_L1_error)
        if (unlikely(!__pyx_t_10)) {
          __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
          __PYX_ERR(0, 6925, __pyx_L1_error)
        }
      }
      #else
      if ((1)); else __PYX_ERR(0, 6925, __pyx_L1_error)
      #endif

 6926: 

 6927:         # Execute the actions in the queue for this timestep

+6928:         if self.action_queue and self.action_queue[0][0] == self.current_timestep:

  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  if (__pyx_t_12) {
  } else {
    __pyx_t_10 = __pyx_t_12;
    goto __pyx_L84_bool_binop_done;
  }
  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_15, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_17 = PyObject_RichCompare(__pyx_t_15, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_17); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_10 = __pyx_t_12;
  __pyx_L84_bool_binop_done:;
  if (likely(__pyx_t_10)) {
/* … */
    goto __pyx_L83;
  }

+6929:             _, thrust, turn_rate, fire, drop_mine = self.action_queue.popleft()

    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_action_queue); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6929, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_3 = __pyx_t_15;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_17 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_popleft, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6929, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_17))) || (PyList_CheckExact(__pyx_t_17))) {
      PyObject* sequence = __pyx_t_17;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 5)) {
        if (size > 5) __Pyx_RaiseTooManyValuesError(5);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 6929, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_15 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_15);
        __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_3);
        __pyx_t_8 = PyTuple_GET_ITEM(sequence, 2);
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 3);
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 4);
        __Pyx_INCREF(__pyx_t_5);
      } else {
        __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 0);
        if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6929, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_15);
        __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 1);
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6929, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_3);
        __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 2);
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6929, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_8);
        __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 3);
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6929, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_4);
        __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 4);
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6929, __pyx_L1_error)
        __Pyx_XGOTREF(__pyx_t_5);
      }
      #else
      {
        Py_ssize_t i;
        PyObject** temps[5] = {&__pyx_t_15,&__pyx_t_3,&__pyx_t_8,&__pyx_t_4,&__pyx_t_5};
        for (i=0; i < 5; i++) {
          PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 6929, __pyx_L1_error)
          __Pyx_GOTREF(item);
          *(temps[i]) = item;
        }
      }
      #endif
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    } else {
      Py_ssize_t index = -1;
      PyObject** temps[5] = {&__pyx_t_15,&__pyx_t_3,&__pyx_t_8,&__pyx_t_4,&__pyx_t_5};
      __pyx_t_1 = PyObject_GetIter(__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6929, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __pyx_t_19 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1);
      for (index=0; index < 5; index++) {
        PyObject* item = __pyx_t_19(__pyx_t_1); if (unlikely(!item)) goto __pyx_L86_unpacking_failed;
        __Pyx_GOTREF(item);
        *(temps[index]) = item;
      }
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_1), 5) < 0) __PYX_ERR(0, 6929, __pyx_L1_error)
      __pyx_t_19 = NULL;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L87_unpacking_done;
      __pyx_L86_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_19 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 6929, __pyx_L1_error)
      __pyx_L87_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_15);
    __pyx_t_15 = 0;
    __pyx_v_thrust = __pyx_t_3;
    __pyx_t_3 = 0;
    __pyx_v_turn_rate = __pyx_t_8;
    __pyx_t_8 = 0;
    __pyx_v_fire = __pyx_t_4;
    __pyx_t_4 = 0;
    __pyx_v_drop_mine = __pyx_t_5;
    __pyx_t_5 = 0;

 6930:         else:

+6931:             raise Exception(f"Sequence error on timestep {self.current_timestep}!")

  /*else*/ {
    __pyx_t_5 = NULL;
    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6931, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6931, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_20[0] = __pyx_mstate_global->__pyx_kp_u_Sequence_error_on_timestep;
    __pyx_t_20[1] = __pyx_t_3;
    __pyx_t_20[2] = __pyx_mstate_global->__pyx_kp_u__16;
    __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_20, 3, 27 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3));
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6931, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8};
      __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6931, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
    }
    __Pyx_Raise(__pyx_t_17, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __PYX_ERR(0, 6931, __pyx_L1_error)
  }
  __pyx_L83:;

 6932:             #thrust, turn_rate, fire, drop_mine = 0.0, 0.0, False, False

 6933: 

 6934:         # The next action in the queue is for a future timestep. All actions for this timestep are processed.

 6935: 

+6936:         if ENABLE_SANITY_CHECKS:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_ENABLE_SANITY_CHECKS); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6936, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6936, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  if (__pyx_t_10) {
/* … */
  }

 6937:             # Bounds check the stuff before the Kessler code complains to me about it  # REMOVE_FOR_COMPETITION

+6938:             if thrust < -SHIP_MAX_THRUST or thrust > SHIP_MAX_THRUST:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6938, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_4 = PyNumber_Negative(__pyx_t_17); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6938, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __pyx_t_17 = PyObject_RichCompare(__pyx_v_thrust, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_17); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6938, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6938, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    if (!__pyx_t_12) {
    } else {
      __pyx_t_10 = __pyx_t_12;
      goto __pyx_L90_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6938, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_4 = PyObject_RichCompare(__pyx_v_thrust, __pyx_t_17, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6938, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6938, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_10 = __pyx_t_12;
    __pyx_L90_bool_binop_done:;
    if (unlikely(__pyx_t_10)) {
/* … */
    }

+6939:                 thrust = min(max(-SHIP_MAX_THRUST, thrust), SHIP_MAX_THRUST)  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6939, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_v_thrust);
      __pyx_t_17 = __pyx_v_thrust;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_THRUST); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6939, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = PyNumber_Negative(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6939, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_17, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6939, __pyx_L1_error)
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6939, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_10) {
        __Pyx_INCREF(__pyx_t_17);
        __pyx_t_8 = __pyx_t_17;
      } else {
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_8 = __pyx_t_5;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_17 = __pyx_t_8;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_17, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6939, __pyx_L1_error)
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6939, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_10) {
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_8 = __pyx_t_4;
      } else {
        __Pyx_INCREF(__pyx_t_17);
        __pyx_t_8 = __pyx_t_17;
      }
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __pyx_t_8;
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF_SET(__pyx_v_thrust, __pyx_t_4);
      __pyx_t_4 = 0;

+6940:                 raise Exception("Dude the thrust is too high, go fix your code >:(")  # REMOVE_FOR_COMPETITION

      __pyx_t_8 = NULL;
      __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
      __pyx_t_17 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Dude_the_thrust_is_too_high_go_f};
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6940, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __PYX_ERR(0, 6940, __pyx_L1_error)

+6941:             if turn_rate < -SHIP_MAX_TURN_RATE or turn_rate > SHIP_MAX_TURN_RATE:  # REMOVE_FOR_COMPETITION

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_17 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = PyObject_RichCompare(__pyx_v_turn_rate, __pyx_t_17, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6941, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6941, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (!__pyx_t_12) {
    } else {
      __pyx_t_10 = __pyx_t_12;
      goto __pyx_L93_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6941, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_17 = PyObject_RichCompare(__pyx_v_turn_rate, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_17); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6941, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6941, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __pyx_t_10 = __pyx_t_12;
    __pyx_L93_bool_binop_done:;
    if (unlikely(__pyx_t_10)) {
/* … */
    }

+6942:                 turn_rate = min(max(-SHIP_MAX_TURN_RATE, turn_rate), SHIP_MAX_TURN_RATE)  # REMOVE_FOR_COMPETITION

      __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6942, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_INCREF(__pyx_v_turn_rate);
      __pyx_t_4 = __pyx_v_turn_rate;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SHIP_MAX_TURN_RATE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6942, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = PyNumber_Negative(__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6942, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6942, __pyx_L1_error)
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6942, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_10) {
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_8 = __pyx_t_4;
      } else {
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_8 = __pyx_t_5;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_4 = __pyx_t_8;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_5 = PyObject_RichCompare(__pyx_t_17, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6942, __pyx_L1_error)
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6942, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (__pyx_t_10) {
        __Pyx_INCREF(__pyx_t_17);
        __pyx_t_8 = __pyx_t_17;
      } else {
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_8 = __pyx_t_4;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __pyx_t_17 = __pyx_t_8;
      __Pyx_INCREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF_SET(__pyx_v_turn_rate, __pyx_t_17);
      __pyx_t_17 = 0;

+6943:                 raise Exception("Dude the turn rate is too high, go fix your code >:(")  # REMOVE_FOR_COMPETITION

      __pyx_t_8 = NULL;
      __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
      __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Dude_the_turn_rate_is_too_high_g};
        __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6943, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
      }
      __Pyx_Raise(__pyx_t_17, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __PYX_ERR(0, 6943, __pyx_L1_error)

+6944:             if fire and not ship_state.can_fire:  # REMOVE_FOR_COMPETITION

    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_fire); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6944, __pyx_L1_error)
    if (__pyx_t_12) {
    } else {
      __pyx_t_10 = __pyx_t_12;
      goto __pyx_L96_bool_binop_done;
    }
    __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_can_fire); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6944, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6944, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    __pyx_t_2 = (!__pyx_t_12);
    __pyx_t_10 = __pyx_t_2;
    __pyx_L96_bool_binop_done:;
    if (unlikely(__pyx_t_10)) {
/* … */
    }

 6945:                 #self.reality_move_sequence.append({'thrust': thrust, 'turn_rate': turn_rate, 'fire': fire, 'drop_mine': drop_mine})  # REMOVE_FOR_COMPETITION

 6946:                 # debug_print(self.reality_move_sequence)  # REMOVE_FOR_COMPETITION

+6947:                 raise Exception("Why are you trying to fire when you haven't waited out the cooldown yet?")  # REMOVE_FOR_COMPETITION

      __pyx_t_4 = NULL;
      __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
      __pyx_t_8 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Why_are_you_trying_to_fire_when};
        __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6947, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
      }
      __Pyx_Raise(__pyx_t_17, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __PYX_ERR(0, 6947, __pyx_L1_error)

 6948:             # debug_print(f"Inputs on timestep {self.current_timestep} - thrust: {thrust}, turn_rate: {turn_rate}, fire: {fire}, drop_mine: {drop_mine}")  # REMOVE_FOR_COMPETITION

 6949: 

+6950:         if float(self.current_timestep) > SLOW_DOWN_GAME_AFTER_SECOND*FPS:  # REMOVE_FOR_COMPETITION

  __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6950, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_8 = __Pyx_PyNumber_Float(__pyx_t_17); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6950, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_SLOW_DOWN_GAME_AFTER_SECOND); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6950, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6950, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyNumber_Multiply(__pyx_t_17, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6950, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyObject_RichCompare(__pyx_t_8, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6950, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6950, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_10) {
/* … */
  }

+6951:             time.sleep(SLOW_DOWN_GAME_PAUSE_TIME)  # REMOVE_FOR_COMPETITION

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6951, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_sleep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6951, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_SLOW_DOWN_GAME_PAUSE_TIME); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6951, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_17))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_17);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_17);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_17, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6951, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+6952:         if GAMESTATE_PLOTTING and self.game_state_to_base_planning and (START_GAMESTATE_PLOTTING_AT_SECOND is None or START_GAMESTATE_PLOTTING_AT_SECOND*FPS <= float(self.current_timestep)):  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_GAMESTATE_PLOTTING); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_10 = __pyx_t_2;
    goto __pyx_L100_bool_binop_done;
  }
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_10 = __pyx_t_2;
    goto __pyx_L100_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = (__pyx_t_4 == Py_None);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!__pyx_t_2) {
  } else {
    __pyx_t_10 = __pyx_t_2;
    goto __pyx_L100_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_START_GAMESTATE_PLOTTING_AT_SECO); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_FPS); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_8 = PyNumber_Multiply(__pyx_t_4, __pyx_t_17); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_4 = __Pyx_PyNumber_Float(__pyx_t_17); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_17 = PyObject_RichCompare(__pyx_t_8, __pyx_t_4, Py_LE); __Pyx_XGOTREF(__pyx_t_17); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6952, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_10 = __pyx_t_2;
  __pyx_L100_bool_binop_done:;
  if (__pyx_t_10) {
/* … */
  }

+6953:             flattened_asteroids_pending_death = [ast for ast_list in self.game_state_to_base_planning['asteroids_pending_death'].values() for ast in ast_list]  # REMOVE_FOR_COMPETITION

    { /* enter inner scope */
      __pyx_t_17 = PyList_New(0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6953, __pyx_L106_error)
      __Pyx_GOTREF(__pyx_t_17);
      __pyx_t_11 = 0;
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6953, __pyx_L106_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_asteroids_pending_death); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6953, __pyx_L106_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(__pyx_t_5 == Py_None)) {
        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
        __PYX_ERR(0, 6953, __pyx_L106_error)
      }
      __pyx_t_8 = __Pyx_dict_iterator(__pyx_t_5, 0, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_21), (&__pyx_t_22)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6953, __pyx_L106_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_4);
      __pyx_t_4 = __pyx_t_8;
      __pyx_t_8 = 0;
      while (1) {
        __pyx_t_23 = __Pyx_dict_iter_next(__pyx_t_4, __pyx_t_21, &__pyx_t_11, NULL, &__pyx_t_8, NULL, __pyx_t_22);
        if (unlikely(__pyx_t_23 == 0)) break;
        if (unlikely(__pyx_t_23 == -1)) __PYX_ERR(0, 6953, __pyx_L106_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_XDECREF_SET(__pyx_9genexpr56__pyx_v_ast_list, __pyx_t_8);
        __pyx_t_8 = 0;
        if (likely(PyList_CheckExact(__pyx_9genexpr56__pyx_v_ast_list)) || PyTuple_CheckExact(__pyx_9genexpr56__pyx_v_ast_list)) {
          __pyx_t_8 = __pyx_9genexpr56__pyx_v_ast_list; __Pyx_INCREF(__pyx_t_8);
          __pyx_t_24 = 0;
          __pyx_t_25 = NULL;
        } else {
          __pyx_t_24 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_9genexpr56__pyx_v_ast_list); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6953, __pyx_L106_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_25 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 6953, __pyx_L106_error)
        }
        for (;;) {
          if (likely(!__pyx_t_25)) {
            if (likely(PyList_CheckExact(__pyx_t_8))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6953, __pyx_L106_error)
                #endif
                if (__pyx_t_24 >= __pyx_temp) break;
              }
              __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_8, __pyx_t_24);
              ++__pyx_t_24;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 6953, __pyx_L106_error)
                #endif
                if (__pyx_t_24 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_24));
              #else
              __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_24);
              #endif
              ++__pyx_t_24;
            }
            if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6953, __pyx_L106_error)
          } else {
            __pyx_t_5 = __pyx_t_25(__pyx_t_8);
            if (unlikely(!__pyx_t_5)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 6953, __pyx_L106_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_5);
          __Pyx_XDECREF_SET(__pyx_9genexpr56__pyx_v_ast, __pyx_t_5);
          __pyx_t_5 = 0;
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_17, (PyObject*)__pyx_9genexpr56__pyx_v_ast))) __PYX_ERR(0, 6953, __pyx_L106_error)
        }
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_9genexpr56__pyx_v_ast); __pyx_9genexpr56__pyx_v_ast = 0;
      __Pyx_XDECREF(__pyx_9genexpr56__pyx_v_ast_list); __pyx_9genexpr56__pyx_v_ast_list = 0;
      goto __pyx_L112_exit_scope;
      __pyx_L106_error:;
      __Pyx_XDECREF(__pyx_9genexpr56__pyx_v_ast); __pyx_9genexpr56__pyx_v_ast = 0;
      __Pyx_XDECREF(__pyx_9genexpr56__pyx_v_ast_list); __pyx_9genexpr56__pyx_v_ast_list = 0;
      goto __pyx_L1_error;
      __pyx_L112_exit_scope:;
    } /* exit inner scope */
    __pyx_v_flattened_asteroids_pending_death = ((PyObject*)__pyx_t_17);
    __pyx_t_17 = 0;

+6954:             assert self.game_state_plotter is not None  # REMOVE_FOR_COMPETITION

    #ifndef CYTHON_WITHOUT_ASSERTIONS
    if (unlikely(__pyx_assertions_enabled())) {
      __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6954, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __pyx_t_10 = (__pyx_t_17 != Py_None);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      if (unlikely(!__pyx_t_10)) {
        __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
        __PYX_ERR(0, 6954, __pyx_L1_error)
      }
    }
    #else
    if ((1)); else __PYX_ERR(0, 6954, __pyx_L1_error)
    #endif

+6955:             self.game_state_plotter.update_plot(game_state.asteroids, ship_state, game_state.bullets, [], [], flattened_asteroids_pending_death, self.game_state_to_base_planning['forecasted_asteroid_splits'], game_state.mines, True, EPS, f'REALITY TIMESTEP {self.current_timestep}')  # REMOVE_FOR_COMPETITION

    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_plotter); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_4 = __pyx_t_8;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_15 = PyList_New(0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_game_state_to_base_planning); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_forecasted_asteroid_splits); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_14);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_mines); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_16 = PyFloat_FromDouble(__pyx_v_14neo_controller_EPS); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_26 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_26);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_REALITY_TIMESTEP, __pyx_t_26); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[12] = {__pyx_t_4, __pyx_t_5, __pyx_v_ship_state, __pyx_t_3, __pyx_t_15, __pyx_t_1, __pyx_v_flattened_asteroids_pending_death, __pyx_t_14, __pyx_t_9, Py_True, __pyx_t_16, __pyx_t_7};
      __pyx_t_17 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update_plot, __pyx_callargs+__pyx_t_6, (12-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6955, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
    }
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+6956:         if REALITY_STATE_DUMP or KEY_STATE_DUMP:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_REALITY_STATE_DUMP); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6956, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6956, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  if (!__pyx_t_2) {
  } else {
    __pyx_t_10 = __pyx_t_2;
    goto __pyx_L114_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_KEY_STATE_DUMP); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6956, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6956, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_10 = __pyx_t_2;
  __pyx_L114_bool_binop_done:;
  if (__pyx_t_10) {
/* … */
  }

 6957:             state_dump_dict = {  # REMOVE_FOR_COMPETITION

+6958:                 'timestep': self.current_timestep,  # REMOVE_FOR_COMPETITION

    __pyx_t_17 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6958, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6958, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (PyDict_SetItem(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_timestep, __pyx_t_8) < 0) __PYX_ERR(0, 6958, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+6959:                 'ship_state': str(ship_state),  # REMOVE_FOR_COMPETITION

    __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_v_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6959, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (PyDict_SetItem(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_ship_state, __pyx_t_8) < 0) __PYX_ERR(0, 6958, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+6960:                 'asteroids': str(game_state.asteroids),  # REMOVE_FOR_COMPETITION

    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_asteroids); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = __Pyx_PyObject_Unicode(__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6960, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (PyDict_SetItem(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_asteroids, __pyx_t_7) < 0) __PYX_ERR(0, 6958, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+6961:                 'bullets': str(game_state.bullets),  # REMOVE_FOR_COMPETITION

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_game_state, __pyx_mstate_global->__pyx_n_u_bullets); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6961, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6961, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (PyDict_SetItem(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_bullets, __pyx_t_8) < 0) __PYX_ERR(0, 6958, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_v_state_dump_dict = ((PyObject*)__pyx_t_17);
    __pyx_t_17 = 0;

 6962:             }  # REMOVE_FOR_COMPETITION

+6963:         if REALITY_STATE_DUMP:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_REALITY_STATE_DUMP); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6963, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6963, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  if (__pyx_t_10) {
/* … */
  }

+6964:             append_dict_to_file(state_dump_dict, 'Reality State Dump.txt')  # REMOVE_FOR_COMPETITION

    __pyx_t_8 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_append_dict_to_file); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6964, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (unlikely(!__pyx_v_state_dump_dict)) { __Pyx_RaiseUnboundLocalError("state_dump_dict"); __PYX_ERR(0, 6964, __pyx_L1_error) }
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_7))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
      assert(__pyx_t_8);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_state_dump_dict, __pyx_mstate_global->__pyx_kp_u_Reality_State_Dump_txt};
      __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6964, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
    }
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+6965:         if KEY_STATE_DUMP and self.current_timestep in self.set_of_base_gamestate_timesteps:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_KEY_STATE_DUMP); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6965, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6965, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_10 = __pyx_t_2;
    goto __pyx_L118_bool_binop_done;
  }
  __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6965, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_of_base_gamestate_timesteps); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6965, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_17, __pyx_t_7, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6965, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_10 = __pyx_t_2;
  __pyx_L118_bool_binop_done:;
  if (__pyx_t_10) {
/* … */
  }

+6966:             append_dict_to_file(state_dump_dict, 'Key Reality State Dump.txt')  # REMOVE_FOR_COMPETITION

    __pyx_t_17 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_append_dict_to_file); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6966, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (unlikely(!__pyx_v_state_dump_dict)) { __Pyx_RaiseUnboundLocalError("state_dump_dict"); __PYX_ERR(0, 6966, __pyx_L1_error) }
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_17);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_17);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_17, __pyx_v_state_dump_dict, __pyx_mstate_global->__pyx_kp_u_Key_Reality_State_Dump_txt};
      __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6966, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+6967:         if VALIDATE_ALL_SIMULATED_STATES and not PRUNE_SIM_STATE_SEQUENCE and not self.other_ships_exist:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_VALIDATE_ALL_SIMULATED_STATES); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6967, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6967, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (__pyx_t_2) {
  } else {
    __pyx_t_10 = __pyx_t_2;
    goto __pyx_L121_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_PRUNE_SIM_STATE_SEQUENCE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6967, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6967, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_12 = (!__pyx_t_2);
  if (__pyx_t_12) {
  } else {
    __pyx_t_10 = __pyx_t_12;
    goto __pyx_L121_bool_binop_done;
  }
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6967, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6967, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_2 = (!__pyx_t_12);
  __pyx_t_10 = __pyx_t_2;
  __pyx_L121_bool_binop_done:;
  if (__pyx_t_10) {
/* … */
  }

 6968:             # debug_print(f"Validating game state for timestep {self.current_timestep}")  # REMOVE_FOR_COMPETITION

+6969:             if self.current_timestep in self.simulated_gamestate_history:  # REMOVE_FOR_COMPETITION

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6969, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6969, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_10 = (__Pyx_PySequence_ContainsTF(__pyx_t_7, __pyx_t_8, Py_EQ)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6969, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_10) {
/* … */
      goto __pyx_L124;
    }

+6970:                 if ship_state != self.simulated_gamestate_history[self.current_timestep].ship_state:  # REMOVE_FOR_COMPETITION

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6970, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6970, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_17 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6970, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6970, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __pyx_t_17 = PyObject_RichCompare(__pyx_v_ship_state, __pyx_t_7, Py_NE); __Pyx_XGOTREF(__pyx_t_17); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6970, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6970, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      if (unlikely(__pyx_t_10)) {
/* … */
      }

+6971:                     print("\nActual ship state:", ship_state)  # REMOVE_FOR_COMPETITION

        __pyx_t_7 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_8 = __pyx_builtin_print; 
        __pyx_t_6 = 1;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_Actual_ship_state, __pyx_v_ship_state};
          __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6971, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
        }
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+6972:                     print("\nSimulated ship state:", self.simulated_gamestate_history[self.current_timestep].ship_state)  # REMOVE_FOR_COMPETITION

        __pyx_t_8 = NULL;
        __Pyx_INCREF(__pyx_builtin_print);
        __pyx_t_7 = __pyx_builtin_print; 
        __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6972, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_16);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6972, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_14 = __Pyx_PyObject_GetItem(__pyx_t_16, __pyx_t_9); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6972, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_14);
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6972, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __pyx_t_6 = 1;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Simulated_ship_state, __pyx_t_9};
          __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6972, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
        }
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+6973:                     raise Exception("Ship states don't match!")  # REMOVE_FOR_COMPETITION

        __pyx_t_7 = NULL;
        __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
        __pyx_t_9 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
        __pyx_t_6 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_Ship_states_don_t_match};
          __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6973, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
        }
        __Pyx_Raise(__pyx_t_17, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __PYX_ERR(0, 6973, __pyx_L1_error)

+6974:                 if not ship_state.is_respawning:  # REMOVE_FOR_COMPETITION

      __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6974, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6974, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __pyx_t_2 = (!__pyx_t_10);
      if (__pyx_t_2) {
/* … */
      }

 6975:                     # If respawning, the asteroid states won't match due to an optimization, so skip the check  # REMOVE_FOR_COMPETITION

+6976:                     simulated_gamestate = cast(GameState, self.simulated_gamestate_history[self.current_timestep].game_state)  # REMOVE_FOR_COMPETITION

        __pyx_t_9 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_cast); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6976, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6976, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6976, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_14);
        __pyx_t_16 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_t_14); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6976, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_16);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6976, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_14);
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        __pyx_t_6 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_7))) {
          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
          assert(__pyx_t_9);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
          __Pyx_INCREF(__pyx_t_9);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
          __pyx_t_6 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_9, ((PyObject *)__pyx_mstate_global->__pyx_ptype_14neo_controller_GameState), __pyx_t_14};
          __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6976, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
        }
        __pyx_v_simulated_gamestate = __pyx_t_17;
        __pyx_t_17 = 0;

+6977:                     if game_state != simulated_gamestate:  # REMOVE_FOR_COMPETITION

        __pyx_t_17 = PyObject_RichCompare(__pyx_v_game_state, __pyx_v_simulated_gamestate, Py_NE); __Pyx_XGOTREF(__pyx_t_17); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6977, __pyx_L1_error)
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6977, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        if (unlikely(__pyx_t_2)) {
/* … */
        }

+6978:                         print("\nActual game state:", game_state)  # REMOVE_FOR_COMPETITION

          __pyx_t_7 = NULL;
          __Pyx_INCREF(__pyx_builtin_print);
          __pyx_t_14 = __pyx_builtin_print; 
          __pyx_t_6 = 1;
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_Actual_game_state, __pyx_v_game_state};
            __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
            if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6978, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
          }
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+6979:                         print("\nSimulated game state:", self.simulated_gamestate_history[self.current_timestep].game_state)  # REMOVE_FOR_COMPETITION

          __pyx_t_14 = NULL;
          __Pyx_INCREF(__pyx_builtin_print);
          __pyx_t_7 = __pyx_builtin_print; 
          __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6979, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6979, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_16);
          __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_9, __pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6979, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
          __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6979, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_16);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_6 = 1;
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_14, __pyx_mstate_global->__pyx_kp_u_Simulated_game_state, __pyx_t_16};
            __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
            __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6979, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
          }
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+6980:                         print(f"\nAnd the simmed ship state is actually {self.simulated_gamestate_history[self.current_timestep].ship_state}")  # REMOVE_FOR_COMPETITION

          __pyx_t_7 = NULL;
          __Pyx_INCREF(__pyx_builtin_print);
          __pyx_t_16 = __pyx_builtin_print; 
          __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simulated_gamestate_history); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6980, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_14);
          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6980, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_t_14, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6980, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6980, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6980, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_And_the_simmed_ship_state_is_ac, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6980, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __pyx_t_6 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
            __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_16, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
            if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6980, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
          }
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+6981:                         raise Exception("Game states don't match!")  # REMOVE_FOR_COMPETITION

          __pyx_t_16 = NULL;
          __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
          __pyx_t_8 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
          __pyx_t_6 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_16, __pyx_mstate_global->__pyx_kp_u_Game_states_don_t_match};
            __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6981, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
          }
          __Pyx_Raise(__pyx_t_17, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __PYX_ERR(0, 6981, __pyx_L1_error)

 6982:             else:  # REMOVE_FOR_COMPETITION

+6983:                 print(f"Timestep not in list of states!!!")  # REMOVE_FOR_COMPETITION

    /*else*/ {
      __pyx_t_8 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_16 = __pyx_builtin_print; 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Timestep_not_in_list_of_states};
        __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_16, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6983, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
      }
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    }
    __pyx_L124:;

+6984:         if (not VALIDATE_ALL_SIMULATED_STATES or PRUNE_SIM_STATE_SEQUENCE) and VALIDATE_SIMULATED_KEY_STATES and self.current_timestep in self.set_of_base_gamestate_timesteps and not self.other_ships_exist:  # REMOVE_FOR_COMPETITION

  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_VALIDATE_ALL_SIMULATED_STATES); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __pyx_t_12 = (!__pyx_t_10);
  if (!__pyx_t_12) {
  } else {
    goto __pyx_L130_next_and;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_PRUNE_SIM_STATE_SEQUENCE); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  if (__pyx_t_12) {
  } else {
    __pyx_t_2 = __pyx_t_12;
    goto __pyx_L129_bool_binop_done;
  }
  __pyx_L130_next_and:;
  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_VALIDATE_SIMULATED_KEY_STATES); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  if (__pyx_t_12) {
  } else {
    __pyx_t_2 = __pyx_t_12;
    goto __pyx_L129_bool_binop_done;
  }
  __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_of_base_gamestate_timesteps); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_12 = (__Pyx_PySequence_ContainsTF(__pyx_t_17, __pyx_t_16, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  if (__pyx_t_12) {
  } else {
    __pyx_t_2 = __pyx_t_12;
    goto __pyx_L129_bool_binop_done;
  }
  __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_other_ships_exist); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_16); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 6984, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  __pyx_t_10 = (!__pyx_t_12);
  __pyx_t_2 = __pyx_t_10;
  __pyx_L129_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

+6985:             debug_print(f"Validating KEY game state for timestep {self.current_timestep}")  # REMOVE_FOR_COMPETITION

    __pyx_t_17 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_debug_print); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6985, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6985, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6985, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Validating_KEY_game_state_for_ti, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6985, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_17);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_17);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_17, __pyx_t_7};
      __pyx_t_16 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6985, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_16);
    }
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;

+6986:             if game_state != self.base_gamestates[self.current_timestep]['game_state']:  # REMOVE_FOR_COMPETITION

    __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestates); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_16);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_16, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyObject_RichCompare(__pyx_v_game_state, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6986, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6986, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(__pyx_t_2)) {
/* … */
    }

+6987:                 print("Actual game state:", game_state)  # REMOVE_FOR_COMPETITION

      __pyx_t_8 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_16 = __pyx_builtin_print; 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Actual_game_state_2, __pyx_v_game_state};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_16, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6987, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+6988:                 print("\nSimulated game state:", self.base_gamestates[self.current_timestep]['game_state'])  # REMOVE_FOR_COMPETITION

      __pyx_t_16 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_8 = __pyx_builtin_print; 
      __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestates); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6988, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6988, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_14 = __Pyx_PyObject_GetItem(__pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6988, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_game_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6988, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_16, __pyx_mstate_global->__pyx_kp_u_Simulated_game_state, __pyx_t_9};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6988, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+6989:                 raise Exception("Game states don't match!")  # REMOVE_FOR_COMPETITION

      __pyx_t_8 = NULL;
      __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
      __pyx_t_9 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_Game_states_don_t_match};
        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6989, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
      }
      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __PYX_ERR(0, 6989, __pyx_L1_error)

+6990:             if ship_state != self.base_gamestates[self.current_timestep]['ship_state']:  # REMOVE_FOR_COMPETITION

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestates); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 6990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 6990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = PyObject_RichCompare(__pyx_v_ship_state, __pyx_t_9, Py_NE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6990, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 6990, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(__pyx_t_2)) {
/* … */
    }

+6991:                 print("Actual ship state:", ship_state)  # REMOVE_FOR_COMPETITION

      __pyx_t_9 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_7 = __pyx_builtin_print; 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_Actual_ship_state_2, __pyx_v_ship_state};
        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6991, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+6992:                 print("\nSimulated ship state:", self.base_gamestates[self.current_timestep]['ship_state'])  # REMOVE_FOR_COMPETITION

      __pyx_t_7 = NULL;
      __Pyx_INCREF(__pyx_builtin_print);
      __pyx_t_9 = __pyx_builtin_print; 
      __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_base_gamestates); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 6992, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_16);
      __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_current_timestep); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6992, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __pyx_t_17 = __Pyx_PyObject_GetItem(__pyx_t_16, __pyx_t_14); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 6992, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_14 = __Pyx_PyObject_Dict_GetItem(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_ship_state); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 6992, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_Simulated_ship_state, __pyx_t_14};
        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6992, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+6993:                 raise Exception("Ship states don't match!")  # REMOVE_FOR_COMPETITION

      __pyx_t_9 = NULL;
      __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
      __pyx_t_14 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
      __pyx_t_6 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_Ship_states_don_t_match};
        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6993, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __PYX_ERR(0, 6993, __pyx_L1_error)

 6994:         #self.reality_move_sequence.append({'thrust': thrust, 'turn_rate': turn_rate, 'fire': fire, 'drop_mine': drop_mine})  # REMOVE_FOR_COMPETITION

 6995:         #print(f"TS: {self.current_timestep}, Thrust: {thrust}, Turn Rate: {turn_rate}, Fire: {fire}, Drop Mine: {drop_mine}")  # REMOVE_FOR_COMPETITION

+6996:         self.performance_controller_exit()

  __pyx_t_14 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_14);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_14, NULL};
    __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_performance_controller_exit, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6996, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
  }
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+6997:         self.last_timestep_ship_is_respawning = ship_state.is_respawning

  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_ship_state, __pyx_mstate_global->__pyx_n_u_is_respawning); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6997, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_last_timestep_ship_is_respawning, __pyx_t_8) < 0) __PYX_ERR(0, 6997, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+6998:         return thrust, turn_rate, fire, drop_mine

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_8 = PyTuple_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 6998, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_v_thrust);
  __Pyx_GIVEREF(__pyx_v_thrust);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_thrust) != (0)) __PYX_ERR(0, 6998, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_turn_rate);
  __Pyx_GIVEREF(__pyx_v_turn_rate);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_turn_rate) != (0)) __PYX_ERR(0, 6998, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_fire);
  __Pyx_GIVEREF(__pyx_v_fire);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_v_fire) != (0)) __PYX_ERR(0, 6998, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_drop_mine);
  __Pyx_GIVEREF(__pyx_v_drop_mine);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_v_drop_mine) != (0)) __PYX_ERR(0, 6998, __pyx_L1_error);
  __pyx_r = ((PyObject*)__pyx_t_8);
  __pyx_t_8 = 0;
  goto __pyx_L0;

 6999: 

 7000: 

+7001: if __name__ == '__main__':

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 7001, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_12 = (__Pyx_PyUnicode_Equals(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_main, Py_EQ)); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 7001, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_12) {
/* … */
  }

+7002:     print("This is a Kessler controller meant to be imported, and not run directly!")

    __pyx_t_5 = NULL;
    __Pyx_INCREF(__pyx_builtin_print);
    __pyx_t_10 = __pyx_builtin_print; 
    __pyx_t_6 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_This_is_a_Kessler_controller_mea};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 7002, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;